﻿using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Xml;
using YArchitech.LIB;
using YArchitech.Revit;

namespace YArchitech.DataModel
{
	public class HVACUserSetting
	{
		public HVACUserSetting()
		{
			this.xmlPath = Path.Combine(Product.UserDataLocation, "HYAirSystemSetting.xml");
			if (!File.Exists(this.xmlPath))
			{
				if (!Directory.Exists(Product.UserDataLocation))
				{
					Directory.CreateDirectory(Product.UserDataLocation);
				}
				File.Copy(Path.Combine(Product.DataLocation, "HYAirSystemSetting.xml"), this.xmlPath);
			}
			this.xmlDoc = XMLOperating.LoadXml(this.xmlPath);
			if ((this.xmlDoc.FirstChild.NextSibling as XmlElement).GetAttribute("version") != "BIMSpace2019")
			{
				File.Copy(Path.Combine(Product.DataLocation, "HYAirSystemSetting.xml"), this.xmlPath, true);
				this.xmlDoc = new XmlDocument();
				this.xmlDoc.Load(this.xmlPath);
				XmlNode nextSibling = this.xmlDoc.FirstChild.NextSibling;
			}
		}

		public string GetValueFromDic(string name, string defaultvalue, Dictionary<string, string> dic)
		{
			string result;
			try
			{
				if (dic.FirstOrDefault((KeyValuePair<string, string> q) => q.Key == name).Value.ToString() == "")
				{
					result = defaultvalue;
				}
				else
				{
					result = dic.FirstOrDefault((KeyValuePair<string, string> q) => q.Key == name).Value.ToString();
				}
			}
			catch
			{
				result = defaultvalue;
			}
			return result;
		}

		public List<string> GetPipeValvesName()
		{
			List<string> list = new List<string>();
			try
			{
				list = XMLOperating.GetAllNodesText(this.xmlDoc, "setting/SpecPipeValves");
			}
			catch (Exception)
			{
				if (list == null || list.Count < 1 || string.IsNullOrEmpty(list.First<string>()))
				{
					list.Add("Y型过滤器");
					list.Add("电动蝶阀");
					list.Add("电动闸阀");
					list.Add("蝶阀1");
					list.Add("蝶阀2");
					list.Add("多孔管");
					list.Add("防爆波阀");
					list.Add("隔膜阀");
					list.Add("减压阀");
					list.Add("可曲挠橡胶头");
					list.Add("气闭隔膜阀");
					list.Add("气动蝶阀");
					list.Add("气动阀");
					list.Add("气开隔膜阀");
					list.Add("球阀");
					list.Add("水流指示器");
					list.Add("套管伸缩器");
					list.Add("温度调节阀");
					list.Add("消声止回阀");
					list.Add("泄压阀");
					list.Add("信号蝶阀");
					list.Add("旋塞阀");
					list.Add("压力调节阀");
					list.Add("遥控信号阀");
					list.Add("液动蝶阀");
					list.Add("液动阀");
					list.Add("闸阀");
					list.Add("电磁阀");
					list.Add("截止阀");
					list.Add("弧形伸缩器");
					list.Add("减压孔板");
					list.Add("疏水器");
				}
			}
			return list;
		}

		public Dictionary<string, string> GetGlobeNozzleFormData()
		{
			return new Dictionary<string, string>
			{
				{
					"nozzleType",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "nozzleType")
				},
				{
					"gIsSheCheng",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gIsSheCheng")
				},
				{
					"gIsFengSu",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gIsFengSu")
				},
				{
					"gIsFengLiang",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gIsFengLiang")
				},
				{
					"gSheCheng",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gSheCheng")
				},
				{
					"gFengSu",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gFengSu")
				},
				{
					"gFengliangL",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gFengliangL")
				},
				{
					"gFengliangM",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gFengliangM")
				},
				{
					"gIsAuto",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gIsAuto")
				},
				{
					"gCol",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gCol")
				},
				{
					"gRow",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "gRow")
				},
				{
					"cIsSheCheng",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cIsSheCheng")
				},
				{
					"cIsQiLiu",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cIsQiLiu")
				},
				{
					"cIsFengLiang",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cIsFengLiang")
				},
				{
					"cCount",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cCount")
				},
				{
					"cFengliangL",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cFengliangL")
				},
				{
					"cFengliangM",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cFengliangM")
				},
				{
					"cSheChengL",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cSheChengL")
				},
				{
					"cSheChengM",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cSheChengM")
				},
				{
					"cQiLiuL",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cQiLiuL")
				},
				{
					"cQiLiuM",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cQiLiuM")
				},
				{
					"cIsAuto",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cIsAuto")
				},
				{
					"cCol",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cCol")
				},
				{
					"cRow",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cRow")
				},
				{
					"cTabIndex",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleLay", "cTabIndex")
				}
			};
		}

		public void WriteNozzleFormData(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "NozzleLay", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetNozzleCalc()
		{
			return new Dictionary<string, string>
			{
				{
					"airSeasonType",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "airSeasonType")
				},
				{
					"paraL",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paraL")
				},
				{
					"paran",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paran")
				},
				{
					"paray",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paray")
				},
				{
					"parax",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "parax")
				},
				{
					"parad",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "parad")
				},
				{
					"paraB",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paraB")
				},
				{
					"paraa",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paraa")
				},
				{
					"parag",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "parag")
				},
				{
					"parats",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "parats")
				},
				{
					"paratn",
					XMLOperating.GetNodeText(this.xmlDoc, "NozzleCalc", "paratn")
				}
			};
		}

		public void WriteNozzleCalc(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "NozzleCalc", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public string[] GetLightByGarageSetting()
		{
			return new string[]
			{
				XMLOperating.GetNodeText(this.xmlDoc, "GarageLight", "FamilyName"),
				XMLOperating.GetNodeText(this.xmlDoc, "GarageLight", "SymbolName")
			};
		}

		public void SaveLightByGarageSetting(string[] lightInfo)
		{
			XMLOperating.EditNodeText(this.xmlPath, "GarageLight", "FamilyName", lightInfo[0]);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLight", "SymbolName", lightInfo[1]);
		}

		public Dictionary<string, string> GetDrainageCalSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"alfab",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "alfab")
				},
				{
					"nFormula",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "nFormula")
				},
				{
					"nMaterType",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "nMaterType")
				},
				{
					"formulaType",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "formulaType")
				},
				{
					"n",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "n")
				},
				{
					"k",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "k")
				},
				{
					"c",
					XMLOperating.GetNodeText(this.xmlDoc, "DrainageCalPara", "c")
				}
			};
		}

		public void WriteDrainageCalSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DrainageCalPara", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetHeatCoolLoadEstimate()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			try
			{
				dictionary.Add("Type", XMLOperating.GetNodeText(this.xmlDoc, "EstimateLoad", "Type"));
				dictionary.Add("Heat", XMLOperating.GetNodeText(this.xmlDoc, "EstimateLoad", "Heat"));
				dictionary.Add("Cool", XMLOperating.GetNodeText(this.xmlDoc, "EstimateLoad", "Cool"));
			}
			catch (Exception ex)
			{
				ex.ToString();
				dictionary.Add("Type", "空间读取");
				dictionary.Add("Heat", "65");
				dictionary.Add("Cool", "90");
			}
			return dictionary;
		}

		public void WriteHeatCoolLoadEstimate(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "EstimateLoad", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetPipeDiameterMark()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			try
			{
				string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "PipeDiameterMark", "Diameter");
				dictionary.Add("Diameter", Convert.ToBoolean(nodeText).ToString());
				dictionary.Add("DiameterValue", XMLOperating.GetNodeText(this.xmlDoc, "PipeDiameterMark", "DiameterValue"));
				dictionary.Add("MarkWay", XMLOperating.GetNodeText(this.xmlDoc, "PipeDiameterMark", "MarkWay"));
				dictionary.Add("MarkStyle", XMLOperating.GetNodeText(this.xmlDoc, "PipeDiameterMark", "MarkStyle"));
				dictionary.Add("MarkLocation", XMLOperating.GetNodeText(this.xmlDoc, "PipeDiameterMark", "MarkLocation"));
			}
			catch (Exception ex)
			{
				ex.ToString();
				dictionary.Add("Diameter", 1.Equals(1).ToString());
				dictionary.Add("DiameterValue", "25");
				dictionary.Add("MarkWay", "单选管道");
				dictionary.Add("MarkStyle", "无引线");
				dictionary.Add("MarkLocation", "线上标注");
			}
			return dictionary;
		}

		public void WritePipeDiameterMark(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeDiameterMark", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetCalcInsulationThickness()
		{
			return new Dictionary<string, string>
			{
				{
					"TabIndex",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "TabIndex")
				},
				{
					"CalcType",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "CalcType")
				},
				{
					"Heating",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Heating")
				},
				{
					"Dewing",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Dewing")
				},
				{
					"LocationName",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "LocationName")
				},
				{
					"InsulationMaterial",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "InsulationMaterial")
				},
				{
					"MediumTemp",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "MediumTemp")
				},
				{
					"DesignTemp",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "DesignTemp")
				},
				{
					"DewingTem",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "DewingTem")
				},
				{
					"Thickness",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Thickness")
				}
			};
		}

		public void WriteCalcInsulationThickness(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public DuctInsulationParam GetPipeInsulationThickness()
		{
			DuctInsulationParam ductInsulationParam = new DuctInsulationParam();
			try
			{
				ductInsulationParam.TabIndex = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "TabIndex"));
				ductInsulationParam.CalcType = XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "CalcType");
				ductInsulationParam.Heating = XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Heating");
				ductInsulationParam.Dewing = XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Dewing");
				ductInsulationParam.LocationName = XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "LocationName");
				ductInsulationParam.InsulationMaterial = XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "InsulationMaterial");
				ductInsulationParam.WarmMediumTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "WarmMediumTemp"));
				ductInsulationParam.PreventMediumTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "PreventMediumTemp"));
				ductInsulationParam.WinterDesignTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "WinterDesignTemp"));
				ductInsulationParam.RoomDewTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "RoomDewTemp"));
				ductInsulationParam.SummerDesignTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "SummerDesignTemp"));
				ductInsulationParam.Thickness = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "PipeInsulationMaterial", "Thickness"));
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				ductInsulationParam.TabIndex = 0;
				ductInsulationParam.CalcType = "保温";
				ductInsulationParam.Heating = "无采暖";
				ductInsulationParam.Dewing = "无空调";
				ductInsulationParam.LocationName = "北京";
				ductInsulationParam.InsulationMaterial = "玻璃棉制品";
				ductInsulationParam.WarmMediumTemp = 60.0;
				ductInsulationParam.PreventMediumTemp = 5.0;
				ductInsulationParam.WinterDesignTemp = 20.0;
				ductInsulationParam.RoomDewTemp = 20.0;
				ductInsulationParam.SummerDesignTemp = 26.0;
				ductInsulationParam.Thickness = 50.0;
			}
			return ductInsulationParam;
		}

		public void WriteCalcPipeInsulationThickness(DuctInsulationParam ductParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "TabIndex", ductParam.TabIndex.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "CalcType", ductParam.CalcType);
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "Heating", ductParam.Heating);
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "Dewing", ductParam.Dewing);
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "LocationName", ductParam.LocationName);
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "InsulationMaterial", ductParam.InsulationMaterial);
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "WarmMediumTemp", ductParam.WarmMediumTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "PreventMediumTemp", ductParam.PreventMediumTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "WinterDesignTemp", ductParam.WinterDesignTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "RoomDewTemp", ductParam.RoomDewTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "SummerDesignTemp", ductParam.SummerDesignTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "PipeInsulationMaterial", "Thickness", ductParam.Thickness.ToString());
		}

		public DuctInsulationParam GetDuctInsulationThickness()
		{
			DuctInsulationParam ductInsulationParam = new DuctInsulationParam();
			try
			{
				ductInsulationParam.TabIndex = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "TabIndex"));
				ductInsulationParam.CalcType = XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "CalcType");
				ductInsulationParam.Heating = XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Heating");
				ductInsulationParam.Dewing = XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Dewing");
				ductInsulationParam.LocationName = XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "LocationName");
				ductInsulationParam.InsulationMaterial = XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "InsulationMaterial");
				ductInsulationParam.WarmMediumTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "WarmMediumTemp"));
				ductInsulationParam.PreventMediumTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "PreventMediumTemp"));
				ductInsulationParam.WinterDesignTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "WinterDesignTemp"));
				ductInsulationParam.RoomDewTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "RoomDewTemp"));
				ductInsulationParam.SummerDesignTemp = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "SummerDesignTemp"));
				ductInsulationParam.Thickness = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Thickness"));
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				ductInsulationParam.TabIndex = 0;
				ductInsulationParam.CalcType = "保温";
				ductInsulationParam.Heating = "无采暖";
				ductInsulationParam.Dewing = "无空调";
				ductInsulationParam.LocationName = "北京";
				ductInsulationParam.InsulationMaterial = "玻璃棉制品";
				ductInsulationParam.WarmMediumTemp = 30.0;
				ductInsulationParam.PreventMediumTemp = 15.0;
				ductInsulationParam.WinterDesignTemp = 20.0;
				ductInsulationParam.RoomDewTemp = 20.0;
				ductInsulationParam.SummerDesignTemp = 26.0;
				ductInsulationParam.Thickness = 50.0;
			}
			return ductInsulationParam;
		}

		public void WriteCalcDuctInsulationThickness(DuctInsulationParam ductParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "TabIndex", ductParam.TabIndex.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "CalcType", ductParam.CalcType);
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "Heating", ductParam.Heating);
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "Dewing", ductParam.Dewing);
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "LocationName", ductParam.LocationName);
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "InsulationMaterial", ductParam.InsulationMaterial);
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "WarmMediumTemp", ductParam.WarmMediumTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "PreventMediumTemp", ductParam.PreventMediumTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "WinterDesignTemp", ductParam.WinterDesignTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "RoomDewTemp", ductParam.RoomDewTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "SummerDesignTemp", ductParam.SummerDesignTemp.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", "Thickness", ductParam.Thickness.ToString());
		}

		public WaterTankFittingFormPara GetWaterTankFittingParam()
		{
			WaterTankFittingFormPara waterTankFittingFormPara = new WaterTankFittingFormPara();
			try
			{
				waterTankFittingFormPara.FittingName = XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "FittingName");
				waterTankFittingFormPara.LevelGageType = XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "LevelGageType");
				waterTankFittingFormPara.CircleManHoleDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "CirecleManHoleDiameter"));
				waterTankFittingFormPara.SquareManHoleSide = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "SquareManHoleSide"));
				waterTankFittingFormPara.SpillwayDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "SpillwayDiameter"));
				waterTankFittingFormPara.SpillwayDisTankBottom = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "SpillwayDisTankBottom"));
				waterTankFittingFormPara.WaterInletType = XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterInletType");
				waterTankFittingFormPara.WaterInletDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterInletDiameter"));
				waterTankFittingFormPara.WaterInletDisTankTop = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterInletDisTankTop"));
				waterTankFittingFormPara.WaterOutletDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterOutletDiameter"));
				waterTankFittingFormPara.WaterOutletDisTankButtom = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterOutletDisTankBottom"));
				waterTankFittingFormPara.WaterVentDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterVentDiameter"));
				waterTankFittingFormPara.WaterVentHeight = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "WaterTankFittingFormPara", "WaterVentHeight"));
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				waterTankFittingFormPara.FittingName = "透气管";
				waterTankFittingFormPara.LevelGageType = "双管";
				waterTankFittingFormPara.CircleManHoleDiameter = 700;
				waterTankFittingFormPara.SquareManHoleSide = 600;
				waterTankFittingFormPara.SpillwayDiameter = 100;
				waterTankFittingFormPara.SpillwayDisTankBottom = 150;
				waterTankFittingFormPara.WaterInletType = "顶进水口";
				waterTankFittingFormPara.WaterInletDiameter = 40;
				waterTankFittingFormPara.WaterInletDisTankTop = 300;
				waterTankFittingFormPara.WaterOutletDiameter = 100;
				waterTankFittingFormPara.WaterOutletDisTankButtom = 150;
				waterTankFittingFormPara.WaterVentDiameter = 100;
				waterTankFittingFormPara.WaterVentHeight = 200;
			}
			return waterTankFittingFormPara;
		}

		public void WriteWaterTankFittingParam(WaterTankFittingFormPara waterTankFittingParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "FittingName", waterTankFittingParam.FittingName);
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "LevelGageType", waterTankFittingParam.LevelGageType);
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "CirecleManHoleDiameter", waterTankFittingParam.CircleManHoleDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "SquareManHoleSide", waterTankFittingParam.SquareManHoleSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "SpillwayDiameter", waterTankFittingParam.SpillwayDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "SpillwayDisTankBottom", waterTankFittingParam.SpillwayDisTankBottom.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterInletType", waterTankFittingParam.WaterInletType.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterInletDiameter", waterTankFittingParam.WaterInletDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterInletDisTankTop", waterTankFittingParam.WaterInletDisTankTop.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterOutletDiameter", waterTankFittingParam.WaterOutletDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterOutletDisTankBottom", waterTankFittingParam.WaterOutletDisTankButtom.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterVentDiameter", waterTankFittingParam.WaterVentDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "WaterTankFittingFormPara", "WaterVentHeight", waterTankFittingParam.WaterVentHeight.ToString());
		}

		public WaterTankFoundationParam GetWaterTankFoundationParam()
		{
			WaterTankFoundationParam waterTankFoundationParam = new WaterTankFoundationParam();
			string text = "1000,1500,2000,2500,3000,3500,4000,4500,5000,5500,6000,6500,7000,7500,8000,8500,9000,9500,10000";
			try
			{
				waterTankFoundationParam.SericesType = XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "sericesType");
				waterTankFoundationParam.Length = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "length"));
				waterTankFoundationParam.Width = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "width"));
				waterTankFoundationParam.Height = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "height"));
				waterTankFoundationParam.FoundationChecked = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "foundationChecked"));
				waterTankFoundationParam.SteelChassisChecked = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "steelChassisChecked"));
				waterTankFoundationParam.Direction = XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "direction");
				waterTankFoundationParam.Span = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "span"));
				waterTankFoundationParam.FoundHeight = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "foundHeight"));
				waterTankFoundationParam.FoundWidth = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "foundWidth"));
				waterTankFoundationParam.FoundLength = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "foundLength"));
				waterTankFoundationParam.SteelChassisHeight = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "steelChassisHeight"));
				waterTankFoundationParam.Offset = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "offset"));
				waterTankFoundationParam.Name = XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "name");
				if (waterTankFoundationParam.SericesType == "装配式钢板水箱" || waterTankFoundationParam.SericesType == "装配式SMC水箱" || waterTankFoundationParam.SericesType == "组合式不锈钢板水箱")
				{
					waterTankFoundationParam.WaterTankLength = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLengthNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLengthNormal") : text);
					waterTankFoundationParam.WaterTankWidth = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidthNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidthNormal") : text);
					waterTankFoundationParam.WaterTankHeight = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeightNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeightNormal") : text);
				}
				else
				{
					waterTankFoundationParam.WaterTankLength = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLength") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLength") : text);
					waterTankFoundationParam.WaterTankWidth = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidth") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidth") : text);
					waterTankFoundationParam.WaterTankHeight = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeight") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeight") : text);
				}
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				waterTankFoundationParam.SericesType = "装配式钢板水箱";
				waterTankFoundationParam.Length = 2000.0;
				waterTankFoundationParam.Width = 2000.0;
				waterTankFoundationParam.Height = 2000.0;
				waterTankFoundationParam.FoundationChecked = true;
				waterTankFoundationParam.SteelChassisChecked = true;
				waterTankFoundationParam.Direction = "水平";
				waterTankFoundationParam.Span = 1000.0;
				waterTankFoundationParam.FoundHeight = 500.0;
				waterTankFoundationParam.FoundWidth = 240.0;
				waterTankFoundationParam.FoundLength = 2200.0;
				waterTankFoundationParam.SteelChassisHeight = 100.0;
				waterTankFoundationParam.Offset = 0.0;
				waterTankFoundationParam.Name = "装配式钢板给水箱";
				waterTankFoundationParam.WaterTankLength = text;
				waterTankFoundationParam.WaterTankWidth = text;
				waterTankFoundationParam.WaterTankHeight = text;
			}
			return waterTankFoundationParam;
		}

		public WaterTankFoundationParam GetWaterTankParam(string sericesType)
		{
			WaterTankFoundationParam waterTankFoundationParam = new WaterTankFoundationParam();
			string text = "1000,1500,2000,2500,3000,3500,4000,4500,5000,5500,6000,6500,7000,7500,8000,8500,9000,9500,10000";
			try
			{
				if (sericesType == "装配式钢板水箱" || sericesType == "装配式SMC水箱" || sericesType == "组合式不锈钢板水箱")
				{
					waterTankFoundationParam.WaterTankLength = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLengthNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLengthNormal") : text);
					waterTankFoundationParam.WaterTankWidth = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidthNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidthNormal") : text);
					waterTankFoundationParam.WaterTankHeight = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeightNormal") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeightNormal") : text);
				}
				else
				{
					waterTankFoundationParam.WaterTankLength = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLength") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankLength") : text);
					waterTankFoundationParam.WaterTankWidth = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidth") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankWidth") : text);
					waterTankFoundationParam.WaterTankHeight = ((XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeight") != "") ? XMLOperating.GetNodeText(this.xmlDoc, "watertanks", "watertankHeight") : text);
				}
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				waterTankFoundationParam.SericesType = "装配式钢板水箱";
				waterTankFoundationParam.Length = 2000.0;
				waterTankFoundationParam.Width = 2000.0;
				waterTankFoundationParam.Height = 2000.0;
				waterTankFoundationParam.FoundationChecked = true;
				waterTankFoundationParam.SteelChassisChecked = true;
				waterTankFoundationParam.Direction = "水平";
				waterTankFoundationParam.Span = 1000.0;
				waterTankFoundationParam.FoundHeight = 500.0;
				waterTankFoundationParam.FoundWidth = 240.0;
				waterTankFoundationParam.FoundLength = 2200.0;
				waterTankFoundationParam.SteelChassisHeight = 100.0;
				waterTankFoundationParam.Offset = 0.0;
				waterTankFoundationParam.Name = "装配式钢板给水箱";
				waterTankFoundationParam.WaterTankLength = text;
				waterTankFoundationParam.WaterTankWidth = text;
				waterTankFoundationParam.WaterTankHeight = text;
			}
			return waterTankFoundationParam;
		}

		public ConnectMultiOnlineParam GetConnectMultiOnlineParam()
		{
			ConnectMultiOnlineParam connectMultiOnlineParam = new ConnectMultiOnlineParam();
			try
			{
				connectMultiOnlineParam.Manifold = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "ConnectMultiOnline", "Manifold"));
				connectMultiOnlineParam.ChangeDouble = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "ConnectMultiOnline", "ChangeDouble"));
				connectMultiOnlineParam.Distance = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "ConnectMultiOnline", "Distance"));
				connectMultiOnlineParam.DistanceEnable = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "ConnectMultiOnline", "DistanceEnable"));
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				connectMultiOnlineParam.Manifold = false;
				connectMultiOnlineParam.ChangeDouble = false;
				connectMultiOnlineParam.Distance = 300.0;
				connectMultiOnlineParam.DistanceEnable = false;
			}
			return connectMultiOnlineParam;
		}

		public void WriteConnectMultiOnlineParam(ConnectMultiOnlineParam connectMultiOnlineParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ConnectMultiOnline", "Manifold", connectMultiOnlineParam.Manifold.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ConnectMultiOnline", "ChangeDouble", connectMultiOnlineParam.ChangeDouble.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ConnectMultiOnline", "Distance", connectMultiOnlineParam.Distance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ConnectMultiOnline", "DistanceEnable", connectMultiOnlineParam.ChangeDouble.ToString());
		}

		public void WriteVRVDimPipeData(VRVDimPipeData dimData)
		{
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimPipe", "WriteDiaToPipe", dimData.IsWriteDiaToPipe.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimPipe", "GasPipeDia", dimData.GasPipeDia);
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimPipe", "LiquidPipeDia", dimData.LiquidPipeDia);
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimPipe", "DimPosition", dimData.DimPosition.ToString());
		}

		public VRVDimPipeData ReadVRVDimPipeData()
		{
			VRVDimPipeData vrvdimPipeData = new VRVDimPipeData();
			vrvdimPipeData.IsWriteDiaToPipe = false;
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimPipe", "WriteDiaToPipe");
			if (nodeText != null && !nodeText.IsEmpty<char>())
			{
				vrvdimPipeData.IsWriteDiaToPipe = Convert.ToBoolean(nodeText);
			}
			string nodeText2 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimPipe", "GasPipeDia");
			if (!nodeText2.IsEmpty<char>())
			{
				vrvdimPipeData.GasPipeDia = nodeText2;
			}
			string nodeText3 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimPipe", "LiquidPipeDia");
			if (!nodeText3.IsEmpty<char>())
			{
				vrvdimPipeData.LiquidPipeDia = nodeText3;
			}
			vrvdimPipeData.DimPosition = 0;
			string nodeText4 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimPipe", "DimPosition");
			if (nodeText4 != null && !nodeText4.IsEmpty<char>())
			{
				vrvdimPipeData.DimPosition = (int)Convert.ToInt16(nodeText4);
			}
			return vrvdimPipeData;
		}

		public void WriteVRVDimEquipData(VRVDimEquipData dimData)
		{
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "IsCustomName", dimData.IsCustomName.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "IsModel", dimData.IsModel.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "IsPrefix", dimData.IsPrefix.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "Prefix", dimData.Prefix);
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "IsCold", dimData.IsCold.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "IsNumber", dimData.IsNumber.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "Number", dimData.Number);
			XMLOperating.EditNodeText(this.xmlPath, "VRVDimEquip", "DimPosition", dimData.DimPosition);
		}

		public VRVDimEquipData ReadVRVDimEquipData()
		{
			VRVDimEquipData vrvdimEquipData = new VRVDimEquipData();
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "IsCustomName");
			if (nodeText != null && !nodeText.IsEmpty<char>())
			{
				vrvdimEquipData.IsCustomName = Convert.ToBoolean(nodeText);
			}
			string nodeText2 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "IsModel");
			if (nodeText2 != null && !nodeText2.IsEmpty<char>())
			{
				vrvdimEquipData.IsModel = Convert.ToBoolean(nodeText2);
			}
			string nodeText3 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "IsPrefix");
			if (nodeText3 != null && !nodeText3.IsEmpty<char>())
			{
				vrvdimEquipData.IsPrefix = Convert.ToBoolean(nodeText3);
			}
			string nodeText4 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "Prefix");
			if (nodeText4 != null && !nodeText4.IsEmpty<char>())
			{
				vrvdimEquipData.Prefix = nodeText4;
			}
			string nodeText5 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "IsCold");
			if (nodeText5 != null && !nodeText5.IsEmpty<char>())
			{
				vrvdimEquipData.IsCold = Convert.ToBoolean(nodeText5);
			}
			string nodeText6 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "IsNumber");
			if (nodeText6 != null && !nodeText6.IsEmpty<char>())
			{
				vrvdimEquipData.IsNumber = Convert.ToBoolean(nodeText6);
			}
			string nodeText7 = XMLOperating.GetNodeText(this.xmlDoc, "VRVDimEquip", "DimPosition");
			if (nodeText7 != null && !nodeText7.IsEmpty<char>())
			{
				vrvdimEquipData.DimPosition = nodeText7;
			}
			return vrvdimEquipData;
		}

		public void WriteVRVCalSysCalMainFormPosition(string x, string y)
		{
			XMLOperating.EditNodeText(this.xmlPath, "VRVSysCal", "SysCalMainFormPositionX", x);
			XMLOperating.EditNodeText(this.xmlPath, "VRVSysCal", "SysCalMainFormPositionY", y);
		}

		public string[] ReadVRVCalSysCalMainFormPosition()
		{
			string[] array = new string[2];
			string text = XMLOperating.GetNodeText(this.xmlDoc, "VRVSysCal", "SysCalMainFormPositionX");
			if (text == null || text.IsEmpty<char>())
			{
				text = "";
			}
			array[0] = text;
			string text2 = XMLOperating.GetNodeText(this.xmlDoc, "VRVSysCal", "SysCalMainFormPositionY");
			if (text2 == null || text2.IsEmpty<char>())
			{
				text2 = "";
			}
			array[1] = text2;
			return array;
		}

		public void WriteVRVCalRuleTemplateName(string calRuleTemplateName)
		{
			XMLOperating.EditNodeText(this.xmlPath, "VRVSysCal", "CalRuleTemplateName", calRuleTemplateName);
		}

		public void WriteVRVRefrigerantTemplateName(string refrigerantTemplateName)
		{
			XMLOperating.EditNodeText(this.xmlPath, "VRVSysCal", "RefrigerantTemplateName", refrigerantTemplateName);
		}

		public string ReadVRVCalRuleTemplateName()
		{
			string text = XMLOperating.GetNodeText(this.xmlDoc, "VRVSysCal", "CalRuleTemplateName");
			if (text == null || text.IsEmpty<char>())
			{
				text = "R22";
			}
			return text;
		}

		public string ReadVRVRefrigerantTemplateName()
		{
			string text = XMLOperating.GetNodeText(this.xmlDoc, "VRVSysCal", "RefrigerantTemplateName");
			if (text == null || text.IsEmpty<char>())
			{
				text = "R22";
			}
			return text;
		}

		public void WriteWaterTankFoundationParam(WaterTankFoundationParam waterTankParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "sericesType", waterTankParam.SericesType);
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "length", waterTankParam.Length.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "width", waterTankParam.Width.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "height", waterTankParam.Height.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "foundationChecked", waterTankParam.FoundationChecked.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "steelChassisChecked", waterTankParam.SteelChassisChecked.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "direction", waterTankParam.Direction);
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "span", waterTankParam.Span.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "foundHeight", waterTankParam.FoundHeight.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "foundWidth", waterTankParam.FoundWidth.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "foundLength", waterTankParam.FoundLength.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "steelChassisHeight", waterTankParam.SteelChassisHeight.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "offset", waterTankParam.Offset.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "name", waterTankParam.Name);
			if (waterTankParam.SericesType == "装配式钢板水箱" || waterTankParam.SericesType == "装配式SMC水箱" || waterTankParam.SericesType == "组合式不锈钢板水箱")
			{
				XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankLengthNormal", waterTankParam.WaterTankLength);
				XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankWidthNormal", waterTankParam.WaterTankWidth);
				XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankHeightNormal", waterTankParam.WaterTankHeight);
				return;
			}
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankLength", waterTankParam.WaterTankLength);
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankWidth", waterTankParam.WaterTankWidth);
			XMLOperating.EditNodeText(this.xmlPath, "watertanks", "watertankHeight", waterTankParam.WaterTankHeight);
		}

		public Dictionary<string, string> GetCalcDuctInsulationThickness()
		{
			return new Dictionary<string, string>
			{
				{
					"TabIndex",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "TabIndex")
				},
				{
					"CalcType",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "CalcType")
				},
				{
					"Heating",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Heating")
				},
				{
					"Dewing",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Dewing")
				},
				{
					"LocationName",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "LocationName")
				},
				{
					"InsulationMaterial",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "InsulationMaterial")
				},
				{
					"MediumTemp",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "MediumTemp")
				},
				{
					"DesignTemp",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "DesignTemp")
				},
				{
					"DewingTem",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "DewingTem")
				},
				{
					"Thickness",
					XMLOperating.GetNodeText(this.xmlDoc, "DuctInsulationMaterial", "Thickness")
				}
			};
		}

		public void WriteCalcDuctInsulationThickness(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DuctInsulationMaterial", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetSupplyCalSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"nFormula",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "nFormula")
				},
				{
					"tbWater",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "tbWater")
				},
				{
					"nPersonNum",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "nPersonNum")
				},
				{
					"tbEquiva",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "tbEquiva")
				},
				{
					"dUserTime",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "dUserTime")
				},
				{
					"hyTextBox3",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "hyTextBox3")
				},
				{
					"tbA",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "tbA")
				},
				{
					"szBuildType",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "szBuildType")
				},
				{
					"c",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "c")
				},
				{
					"dJz",
					XMLOperating.GetNodeText(this.xmlDoc, "SupplyCalPara", "dJz")
				}
			};
		}

		public void WriteSupplyCalSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "SupplyCalPara", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetAirPressureTankSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"alfab",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "alfab")
				},
				{
					"h1",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "h1")
				},
				{
					"h2",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "h2")
				},
				{
					"h4",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "h4")
				},
				{
					"bita",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "bita")
				},
				{
					"n",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "n")
				},
				{
					"qb",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "qb")
				},
				{
					"c",
					XMLOperating.GetNodeText(this.xmlDoc, "AirPressureTankInfo", "c")
				}
			};
		}

		public void WriteAirPressureTankSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "AirPressureTankInfo", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetLaySubWaterCatcherSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"count",
					XMLOperating.GetNodeText(this.xmlDoc, "LaySubWaterCatcherInfo", "count")
				},
				{
					"isHave",
					XMLOperating.GetNodeText(this.xmlDoc, "LaySubWaterCatcherInfo", "isHave")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "LaySubWaterCatcherInfo", "offset")
				}
			};
		}

		public void WriteLaySubWaterCatcherSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LaySubWaterCatcherInfo", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetLayPumpBaseSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"isDamp",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpBaseInfo", "isDamp")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpBaseInfo", "offset")
				},
				{
					"isPutDownThePump",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpBaseInfo", "isPutDownThePump")
				}
			};
		}

		public void WriteLayPumpBaseSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LayPumpBaseInfo", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetLayPumpSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"name",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "name")
				},
				{
					"specIndex",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "specIndex")
				},
				{
					"isDamp",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "isDamp")
				},
				{
					"isLayBase",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "isLayBase")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "offset")
				},
				{
					"distance",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "distance")
				},
				{
					"page",
					XMLOperating.GetNodeText(this.xmlDoc, "LayPumpInfo", "page")
				}
			};
		}

		public void WriteLayPumpSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LayPumpInfo", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetFansLaySetting()
		{
			return new Dictionary<string, string>
			{
				{
					"HYDuctFan",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "HYDuctFan")
				},
				{
					"CurrentFanType",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "CurrentFanType")
				},
				{
					"CurrentRelativeLevel",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "CurrentRelativeLevel")
				},
				{
					"CurrentConnectLength",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "CurrentConnectLength")
				},
				{
					"familyName",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "familyName")
				},
				{
					"familySymbol",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "familySymbol")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "offset")
				},
				{
					"layduct",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "layduct")
				},
				{
					"width",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "width")
				},
				{
					"length",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "length")
				},
				{
					"flexLength",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "flexLength")
				},
				{
					"diameter",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "diameter")
				},
				{
					"layflex",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "layflex")
				},
				{
					"height",
					XMLOperating.GetNodeText(this.xmlDoc, "fans", "height")
				}
			};
		}

		public void WriteFansLaySetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "fans", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetFireExtinguisherLaySetting()
		{
			return new Dictionary<string, string>
			{
				{
					"familyCategory",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "familyCategory")
				},
				{
					"familyName",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "familyName")
				},
				{
					"layTerminalType",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "layTerminalType")
				},
				{
					"radius",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "radius")
				},
				{
					"category",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "category")
				},
				{
					"class",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "class")
				},
				{
					"count",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "count")
				},
				{
					"scale",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "scale")
				},
				{
					"islable",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "islable")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "offset")
				},
				{
					"range",
					XMLOperating.GetNodeText(this.xmlDoc, "fireExtinguisher", "range")
				}
			};
		}

		public void WriteFireExtinguisherLaySetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "fireExtinguisher", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetFireExtinguisherCalSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"dishang",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "dishang")
				},
				{
					"leibie",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "leibie")
				},
				{
					"jibie",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "jibie")
				},
				{
					"changdi",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "changdi")
				},
				{
					"mianji",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "mianji")
				},
				{
					"count",
					XMLOperating.GetNodeText(this.xmlDoc, "FireExtinguisherCalculate", "count")
				}
			};
		}

		public void WriteFireExtinguisherCalSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FireExtinguisherCalculate", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetWaterTankSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"name",
					XMLOperating.GetNodeText(this.xmlDoc, "WaterTankInfo", "name")
				},
				{
					"specIndex",
					XMLOperating.GetNodeText(this.xmlDoc, "WaterTankInfo", "specIndex")
				},
				{
					"offset",
					XMLOperating.GetNodeText(this.xmlDoc, "WaterTankInfo", "offset")
				}
			};
		}

		public void WriteWaterTankSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "WaterTankInfo", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public HYFireData GetProtectRadiusSet()
		{
			HYFireData hyfireData = new HYFireData();
			try
			{
				hyfireData.ILength = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "length"));
				hyfireData.IMaterial = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "material"));
				hyfireData.IType = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "type"));
				hyfireData.IDiameter = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "diameter"));
				hyfireData.DMinFlow = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "minFlow"));
				hyfireData.DMinLength = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "minLength"));
				hyfireData.IKnow = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "known"));
				hyfireData.DFlow = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "flow"));
				hyfireData.DPressure = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "pressure"));
				hyfireData.DRadius = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "radius"));
				hyfireData.IImport = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ProtectRadius", "import"));
			}
			catch (Exception)
			{
				hyfireData.ILength = 20;
				hyfireData.IMaterial = 0;
				hyfireData.IType = 0;
				hyfireData.IDiameter = 0;
				hyfireData.DMinFlow = 5.0;
				hyfireData.DMinLength = 0.0;
				hyfireData.IKnow = 0;
				hyfireData.DFlow = 19.0;
				hyfireData.DPressure = 19.0;
				hyfireData.DRadius = 19.0;
				hyfireData.IImport = 0;
			}
			return hyfireData;
		}

		public void WriteProtectRadiusSet(HYFireData fireData)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "length", fireData.ILength.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "material", fireData.IMaterial.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "type", fireData.IType.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "diameter", fireData.IDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "minFlow", fireData.DMinFlow.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "minLength", fireData.DMinLength.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "known", fireData.IKnow.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "flow", fireData.DFlow.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "pressure", fireData.DPressure.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "radius", fireData.DRadius.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ProtectRadius", "import", fireData.IImport.ToString());
		}

		public CoilTrackConn GetCoilTrackConn()
		{
			CoilTrackConn coilTrackConn = new CoilTrackConn();
			try
			{
				coilTrackConn.SupplySysName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SupplySysName");
				coilTrackConn.SupplyPipeName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SupplyPipeName");
				coilTrackConn.SupplyDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SupplyDiameter"));
				coilTrackConn.SupplyOffset = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SupplyOffset"));
				coilTrackConn.SupplyDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SupplyDistance"));
				coilTrackConn.ReturnSysName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "ReturnSysName");
				coilTrackConn.ReturnPipeName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "ReturnPipeName");
				coilTrackConn.ReturnDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "ReturnDiameter"));
				coilTrackConn.ReturnOffset = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "ReturnOffset"));
				coilTrackConn.ReturnDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "ReturnDistance"));
				coilTrackConn.SanitarySysName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SanitarySysName");
				coilTrackConn.SanitaryPipeName = XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SanitaryPipeName");
				coilTrackConn.SanitaryDiameter = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SanitaryDiameter"));
				coilTrackConn.SanitaryOffset = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SanitaryOffset"));
				coilTrackConn.SanitaryDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CoilTrackConn", "SanitaryDistance"));
			}
			catch (Exception)
			{
				coilTrackConn.SupplySysName = "循环供水";
				coilTrackConn.SupplyPipeName = "标准";
				coilTrackConn.SupplyDiameter = 50;
				coilTrackConn.SupplyOffset = 2.75;
				coilTrackConn.SupplyDistance = 100;
				coilTrackConn.ReturnSysName = "循环回水";
				coilTrackConn.ReturnPipeName = "标准";
				coilTrackConn.ReturnDiameter = 50;
				coilTrackConn.ReturnOffset = 2.65;
				coilTrackConn.ReturnDistance = 100;
				coilTrackConn.SanitarySysName = "卫生设备";
				coilTrackConn.SanitaryPipeName = "标准";
				coilTrackConn.SanitaryDiameter = 50;
				coilTrackConn.SanitaryOffset = 2.55;
				coilTrackConn.SanitaryDistance = 100;
			}
			return coilTrackConn;
		}

		public void WriteCoilTrackConn(CoilTrackConn ctc)
		{
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SupplySysName", ctc.SupplySysName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SupplyPipeName", ctc.SupplyPipeName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SupplyDiameter", ctc.SupplyDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SupplyOffset", ctc.SupplyOffset.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SupplyDistance", ctc.SupplyDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "ReturnSysName", ctc.ReturnSysName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "ReturnPipeName", ctc.ReturnPipeName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "ReturnDiameter", ctc.ReturnDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "ReturnOffset", ctc.ReturnOffset.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "ReturnDistance", ctc.ReturnDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SanitarySysName", ctc.SanitarySysName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SanitaryPipeName", ctc.SanitaryPipeName);
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SanitaryDiameter", ctc.SanitaryDiameter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SanitaryOffset", ctc.SanitaryOffset.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CoilTrackConn", "SanitaryDistance", ctc.SanitaryDistance.ToString());
		}

		public CalcDuctSpeed GetCalcDuctSpeed()
		{
			CalcDuctSpeed calcDuctSpeed = new CalcDuctSpeed();
			try
			{
				calcDuctSpeed.DuctFlow = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "CalcDuctSpeed", "DuctFlow"));
				calcDuctSpeed.SecType = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CalcDuctSpeed", "SecType"));
				calcDuctSpeed.DuctWidth = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CalcDuctSpeed", "DuctWidth"));
				calcDuctSpeed.DuctHeight = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "CalcDuctSpeed", "DuctHeight"));
			}
			catch (Exception)
			{
				calcDuctSpeed.DuctFlow = 500.0;
				calcDuctSpeed.SecType = 0;
				calcDuctSpeed.DuctWidth = 400;
				calcDuctSpeed.DuctHeight = 160;
			}
			return calcDuctSpeed;
		}

		public void WriteCalcDuctSpeed(CalcDuctSpeed cds)
		{
			XMLOperating.EditNodeText(this.xmlPath, "CalcDuctSpeed", "DuctFlow", cds.DuctFlow.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CalcDuctSpeed", "SecType", cds.SecType.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CalcDuctSpeed", "DuctWidth", cds.DuctWidth.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "CalcDuctSpeed", "DuctHeight", cds.DuctHeight.ToString());
		}

		public FloorPipeConnParam GetFloorPipeConn()
		{
			FloorPipeConnParam floorPipeConnParam = new FloorPipeConnParam();
			try
			{
				floorPipeConnParam.ScDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeConn", "ScDistance"));
				floorPipeConnParam.FpDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeConn", "FpDistance"));
				floorPipeConnParam.BtDistance = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeConn", "BtDistance"));
			}
			catch (Exception)
			{
				floorPipeConnParam.ScDistance = 150;
				floorPipeConnParam.FpDistance = 200;
				floorPipeConnParam.BtDistance = 200;
			}
			return floorPipeConnParam;
		}

		public void WriteFloorPipeConn(FloorPipeConnParam fpcp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "FloorPipeConn", "ScDistance", fpcp.ScDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "FloorPipeConn", "FpDistance", fpcp.FpDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "FloorPipeConn", "BtDistance", fpcp.BtDistance.ToString());
		}

		public SupplyWaterConn GetSupplyWaterConn()
		{
			SupplyWaterConn supplyWaterConn = new SupplyWaterConn();
			try
			{
				supplyWaterConn.ConnStyle = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "ConnStyle"));
				supplyWaterConn.WaterMeter = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "WaterMeter"));
				supplyWaterConn.MainPipeOffset = XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "MainPipeOffset");
				supplyWaterConn.ValveOffset = XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "ValveOffset");
				supplyWaterConn.Diameter = XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "Diameter");
				supplyWaterConn.Angle = XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "Angle");
				supplyWaterConn.BeDraw = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "BeDraw"));
				supplyWaterConn.BLinkBathe = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "BLinkBathe"));
				supplyWaterConn.BIsParallel = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SupplyWaterConn", "BIsParallel"));
			}
			catch (Exception)
			{
				supplyWaterConn.ConnStyle = true;
				supplyWaterConn.WaterMeter = true;
				supplyWaterConn.MainPipeOffset = "0";
				supplyWaterConn.ValveOffset = "100";
				supplyWaterConn.Diameter = "32";
				supplyWaterConn.Angle = "0";
				supplyWaterConn.BeDraw = true;
				supplyWaterConn.BLinkBathe = false;
				supplyWaterConn.BIsParallel = true;
			}
			return supplyWaterConn;
		}

		public void WriteSupplyWaterConn(SupplyWaterConn swc)
		{
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "ConnStyle", swc.ConnStyle.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "WaterMeter", swc.WaterMeter.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "BeDraw", swc.BeDraw.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "ValveOffset", swc.ValveOffset);
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "MainPipeOffset", swc.MainPipeOffset);
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "Diameter", swc.Diameter);
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "Angle", swc.Angle);
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "BLinkBathe", swc.BLinkBathe.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SupplyWaterConn", "BIsParallel", swc.BIsParallel.ToString());
		}

		public ConnRadiatorSet GetConnRadiatorSet()
		{
			ConnRadiatorSet connRadiatorSet = new ConnRadiatorSet();
			try
			{
				connRadiatorSet.ConnStyle = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "ConnRadiator", "ConnStyle"));
				connRadiatorSet.ReturnName = XMLOperating.GetNodeText(this.xmlDoc, "ConnRadiator", "ReturnSet");
				connRadiatorSet.SupplyName = XMLOperating.GetNodeText(this.xmlDoc, "ConnRadiator", "SupplySet");
				connRadiatorSet.ReturnLength = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "ConnRadiator", "RevturnLength"));
				connRadiatorSet.SupplyLength = Convert.ToInt32(XMLOperating.GetNodeText(this.xmlDoc, "ConnRadiator", "SupplyLength"));
			}
			catch (Exception)
			{
				connRadiatorSet.ConnStyle = 1;
				connRadiatorSet.ReturnName = "球阀";
				connRadiatorSet.SupplyName = "压力调节阀";
				connRadiatorSet.ReturnLength = 600;
				connRadiatorSet.SupplyLength = 500;
			}
			return connRadiatorSet;
		}

		public void WriteConnRadiatorSet(ConnRadiatorSet crs)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ConnRadiator", "ConnStyle", crs.ConnStyle.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ConnRadiator", "SupplySet", crs.SupplyName);
			XMLOperating.EditNodeText(this.xmlPath, "ConnRadiator", "ReturnSet", crs.ReturnName);
			XMLOperating.EditNodeText(this.xmlPath, "ConnRadiator", "RevturnLength", crs.ReturnLength.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ConnRadiator", "SupplyLength", crs.SupplyLength.ToString());
		}

		public string[] GetDuctcmbValveTypeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DuctValueSetting", "cmbValveType");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DuctValueSetting", "tabValue");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DuctValueSetting", "selectNote");
			return array;
		}

		public void WriteDuctcmbValveTypeText(string[] texts)
		{
			if (texts.Count<string>() > 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DuctValueSetting", "cmbValveType", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctValueSetting", "tabValue", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctValueSetting", "selectNote", texts[2]);
			}
		}

		public string[] GetPipecmbValveTypeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "PipeValueSetting", "cmbValveType");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "PipeValueSetting", "tabValue");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "PipeValueSetting", "selectNote");
			return array;
		}

		public void WritePipecmbValveTypeText(string[] texts)
		{
			if (texts.Count<string>() > 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeValueSetting", "cmbValveType", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeValueSetting", "tabValue", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeValueSetting", "selectNote", texts[2]);
			}
		}

		public string GetAccessoryText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "laysetting", "accessory");
		}

		public void WriteAccessoryText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "laysetting", "accessory", text);
		}

		public string GetPipeAccessoryText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "laysetting", "pipeaccessory");
		}

		public void WritePipeAccessoryText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "laysetting", "pipeaccessory", text);
		}

		public string GetDuctConnTerminalStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductterminalconn", "connstyle");
		}

		public void WriteDuctConnTerminalStyle(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductterminalconn", "connstyle", connStyle);
		}

		public string GetDuctConnAlignTerminalType()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductterminalconn", "connAlign");
		}

		public void WriteDuctConnAlignTerminalType(string alignType)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductterminalconn", "connAlign", alignType);
		}

		public string GetBatchConnTerminalStyle()
		{
			string result;
			try
			{
				result = XMLOperating.GetNodeText(this.xmlDoc, "batchterminalconn", "connstyle");
			}
			catch (Exception)
			{
				result = "Fitting";
			}
			return result;
		}

		public void WriteBatchConnTerminalStyle(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "batchterminalconn", "connstyle", connStyle);
		}

		public string GetDuctConnStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "connstyle");
		}

		public void WriteDuctConnStyle(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "connstyle", connStyle);
		}

		public string getDuctConnSelectStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "connSelectStyle");
		}

		public void WriteDuctConnSelectStyle(string connSelectStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "connSelectStyle", connSelectStyle);
		}

		public string GetAutoDesignSetting(string nodeName)
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "autodesign", nodeName);
		}

		public void WriteAutoDesignSetting(string nodeName, string nodeValue)
		{
			XMLOperating.EditNodeText(this.xmlPath, "autodesign", nodeName, nodeValue);
		}

		public string GetDuctConnTeeStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "tee");
		}

		public void WriteDuctConnTeeStyle(string teeStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "tee", teeStyle);
		}

		public Dictionary<string, string> GetPipeArrangementSetting()
		{
			return new Dictionary<string, string>
			{
				{
					"SpacingType",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeArrangement", "SpacingType")
				},
				{
					"CenterSpacing",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeArrangement", "CenterSpacing")
				},
				{
					"SideSpacing",
					XMLOperating.GetNodeText(this.xmlDoc, "PipeArrangement", "SideSpacing")
				}
			};
		}

		public void WritePipeArrangementSetting(Dictionary<string, string> dicPipeSetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicPipeSetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeArrangement", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetSectorLaySetting()
		{
			return new Dictionary<string, string>
			{
				{
					"familyCategory",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "familyCategory")
				},
				{
					"familyName",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "familyName")
				},
				{
					"familySymbolName",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "familySymbolName")
				},
				{
					"drawRange",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "drawRange")
				},
				{
					"layStyle",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "layStyle")
				},
				{
					"limitedSector",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "limitedSector")
				},
				{
					"limitedArc",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "limitedArc")
				},
				{
					"divisor",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "divisor")
				},
				{
					"drawLength",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "drawLength")
				},
				{
					"dangerLevel",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "dangerLevel")
				},
				{
					"sectorCol",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "sectorCol")
				},
				{
					"sectorRow",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "sectorRow")
				},
				{
					"sectorRatio",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "sectorRatio")
				},
				{
					"arcNum",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "arcNum")
				},
				{
					"arcRatio",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "arcRatio")
				},
				{
					"arcDistance",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "arcDistance")
				},
				{
					"arcSide",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "arcSide")
				},
				{
					"offSet",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "offSet")
				},
				{
					"radius",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "radius")
				},
				{
					"kCoffie",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "kCoffie")
				},
				{
					"isConn",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "isConn")
				},
				{
					"pipeType",
					XMLOperating.GetNodeText(this.xmlDoc, "sprinklersSector", "pipeType")
				}
			};
		}

		public void WriteSectorLaySetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "sprinklersSector", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public string GetDuctConnRoundTeeStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "ronudtee");
		}

		public void WriteDuctConnRoundTeeStyle(string teeStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "ronudtee", teeStyle);
		}

		public string GetDuctConnElbowStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "elbow");
		}

		public void WriteDuctConnElbowStyle(string elbowStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "elbow", elbowStyle);
		}

		public string GetDuctConnRoundElbowStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "roundelbow");
		}

		public void WriteDuctConnRoundElbowStyle(string elbowStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "roundelbow", elbowStyle);
		}

		public string GetDuctConnCrossStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "cross");
		}

		public void WriteDuctConnCrossStyle(string crossStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "cross", crossStyle);
		}

		public string GetDuctConnRoundCrossStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "roundcross");
		}

		public void WriteDuctConnRoundCrossStyle(string crossStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "roundcross", crossStyle);
		}

		public string GetDuctConnReduceStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "reduce");
		}

		public void WriteDuctConnReduceStyle(string reduceStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "reduce", reduceStyle);
		}

		public string GetDuctConnRoundStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "round");
		}

		public void WriteDuctConnRoundStyle(string roundStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "round", roundStyle);
		}

		public string GetDuctConnLateralStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "lateral");
		}

		public void WriteDuctConnLateralStyle(string lateralStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "lateral", lateralStyle);
		}

		public string GetDuctShapeStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "ductshape");
		}

		public void WriteDuctShapeStyle(string shapeStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "ductshape", shapeStyle);
		}

		public string GetRevitPeizhi()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "isrevit");
		}

		public void WriteRevitPeizhi(string isrevit)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "isrevit", isrevit);
		}

		public string GetDuctConnBackStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductconn", "back");
		}

		public void WriteDuctConnBackStyle(string backStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductconn", "back", backStyle);
		}

		public string GetPipeConnStyle()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "pipeConn", "connstyle");
		}

		public void WritePipeConnStyle(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipeConn", "connstyle", connStyle);
		}

		public string GetHConnRPipeTee()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "pipeConn", "hrtee");
		}

		public string GetHConnRPipeAlign()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "pipeConn", "align");
		}

		public string GetHConnRPipeDiameter()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "pipeConn", "diameter");
		}

		public void WriteHConnRPipeTee(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipeConn", "hrtee", connStyle);
		}

		public void WriteHConnRPipeAlign(string connStyle)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipeConn", "align", connStyle);
		}

		public void WriteHConnRPipeDiameter(string connDiameter)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipeConn", "diameter", connDiameter);
		}

		public string GetTRPipeConnectText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "TRPipeConnect", "model");
		}

		public void WriteTRPipeConnectText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "TRPipeConnect", "model", text);
		}

		public string GetConnectTrapText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ConnectTrap", "model");
		}

		public void WriteConnectTrapText(int index)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ConnectTrap", "model", index.ToString());
		}

		public IList<string> GetSupplyWaterCal()
		{
			IList<string> list = new List<string>();
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "PipeType");
			string nodeText2 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Diameter");
			string nodeText3 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Speed");
			if (string.IsNullOrEmpty(nodeText) || string.IsNullOrEmpty(nodeText2) || string.IsNullOrEmpty(nodeText3))
			{
				list.Add("标准");
				list.Add("50");
				list.Add("10");
			}
			else
			{
				list.Add(XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "PipeType"));
				list.Add(XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Diameter"));
				list.Add(XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Speed"));
			}
			return list;
		}

		public void WriteSupplyWaterCal(IList<string> listStr)
		{
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "PipeType", listStr[0]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "Diameter", listStr[1]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "Speed", listStr[2]);
		}

		public IList<string> GetCisternCal()
		{
			IList<string> list = new List<string>();
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Supply");
			string nodeText2 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "OutWater");
			string nodeText3 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "RunTime");
			string nodeText4 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "RunInterval");
			string nodeText5 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "ContinueTime");
			string nodeText6 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "InDoorWater");
			string nodeText7 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "OutDoorWater");
			string nodeText8 = XMLOperating.GetNodeText(this.xmlDoc, "CisternCal", "Spray");
			if (string.IsNullOrEmpty(nodeText) || string.IsNullOrEmpty(nodeText2) || string.IsNullOrEmpty(nodeText3) || string.IsNullOrEmpty(nodeText4) || string.IsNullOrEmpty(nodeText5) || string.IsNullOrEmpty(nodeText6) || string.IsNullOrEmpty(nodeText7) || string.IsNullOrEmpty(nodeText8))
			{
				list.Add("42.41");
				list.Add("70");
				list.Add("1");
				list.Add("1");
				list.Add("3");
				list.Add("40");
				list.Add("30");
				list.Add("30");
			}
			else
			{
				list.Add(nodeText);
				list.Add(nodeText2);
				list.Add(nodeText3);
				list.Add(nodeText4);
				list.Add(nodeText5);
				list.Add(nodeText6);
				list.Add(nodeText7);
				list.Add(nodeText8);
			}
			return list;
		}

		public void WriteCisternCal(IList<string> listStr)
		{
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "Supply", listStr[0]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "OutWater", listStr[1]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "RunTime", listStr[2]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "RunInterval", listStr[3]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "ContinueTime", listStr[4]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "InDoorWater", listStr[5]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "OutDoorWater", listStr[6]);
			XMLOperating.EditNodeText(this.xmlPath, "CisternCal", "Spray", listStr[7]);
		}

		public void WritePipeAlignmentText(string[] texts)
		{
			if (texts.Count<string>() >= 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeAlignmentText", "style", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeAlignmentText", "message", texts[1]);
			}
		}

		public string[] GetPipeAlignmentText()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "PipeAlignmentText", "style");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "PipeAlignmentText", "message");
			return array;
		}

		public void WritearoundbeamText(string[] texts)
		{
			if (texts.Count<string>() >= 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "aroundbeam", "length", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "aroundbeam", "angle", texts[1]);
			}
		}

		public string[] GetaroundbeamText()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "aroundbeam", "length");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "aroundbeam", "angle");
			return array;
		}

		public string GetWaterPipeAccessoryText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "laysetting", "waterpipeaccessory");
		}

		public void WriteWaterPipeAccessoryText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "laysetting", "waterpipeaccessory", text);
		}

		public string GetWaterGPipeAccessoryText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "laysetting", "watergpipeaccessory");
		}

		public void WriteWaterGPipeAccessoryText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "laysetting", "watergpipeaccessory", text);
		}

		public string GetWaterPPipeAccessoryText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "laysetting", "waterppipeaccessory");
		}

		public void WriteWaterPPipeAccessoryText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "laysetting", "waterppipeaccessory", text);
		}

		public string GetFireHDTypeValue()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "fireHDtype", "type");
		}

		public bool GetFireHDStyleValue()
		{
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "fireHDtype", "style");
			return !string.IsNullOrEmpty(nodeText) && nodeText.ToLower() == "true";
		}

		public void WriteFireHDType(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "fireHDtype", "type", text);
		}

		public void WriteFireHDStyle(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "fireHDtype", "style", text);
		}

		public string[] GetSprinklerDistance()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "sprinklerDistance", "type");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "sprinklerDistance", "distance");
			return array;
		}

		public void WriteGetSprinklerDistance(string[] texts)
		{
			XMLOperating.EditNodeText(this.xmlPath, "sprinklerDistance", "type", texts[0]);
			XMLOperating.EditNodeText(this.xmlPath, "sprinklerDistance", "distance", texts[1]);
		}

		public void writeDrainageSystemSetting(string[] texts)
		{
			if (texts.Count<string>() >= 4)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "PipeClass", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "PipeClass", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "PipingSystemType", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "PipingSystemType", texts[3]);
			}
		}

		public string[] GetRiserPipeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "PipeClass");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "PipingSystemType");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "PipeDiameter");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "OffsetDown");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "OffsetUp");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "IsFirst");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "level1");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalPipeSetting", "level2");
			return array;
		}

		public void WriteRiserPipeText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "PipeClass", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "PipingSystemType", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "PipeDiameter", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "OffsetDown", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "OffsetUp", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "IsFirst", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "level1", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalPipeSetting", "level2", texts[7]);
			}
		}

		public string[] GetRiserHeatingPipeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "PipeClass");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "PipingSystemType");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "PipeDiameter");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "OffsetDown");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "OffsetUp");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "IsFirst");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "level1");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "FormReiseDrawHeatingPipe", "level2");
			return array;
		}

		public void WriteRiserHeatingPipeText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "PipeClass", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "PipingSystemType", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "PipeDiameter", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "OffsetDown", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "OffsetUp", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "IsFirst", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "level1", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "FormReiseDrawHeatingPipe", "level2", texts[7]);
			}
		}

		public string[] GetThwartwisePipeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DrawThwartwisePipeSetting", "PipeDiameter");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DrawThwartwisePipeSetting", "Level");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DrawThwartwisePipeSetting", "Offset");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "DrawThwartwisePipeSetting", "slope");
			return array;
		}

		public void WriteThwartwisePipeText(string[] texts)
		{
			if (texts.Count<string>() >= 4)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "PipeDiameter", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "Level", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "Offset", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawThwartwisePipeSetting", "slope", texts[3]);
			}
		}

		public string[] GetHeatingPipeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DrawHeatingPipeSetting", "PipeDiameter");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DrawHeatingPipeSetting", "Level");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DrawHeatingPipeSetting", "Offset");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "DrawHeatingPipeSetting", "slope");
			return array;
		}

		public void WriteHeatingPipeText(string[] texts)
		{
			if (texts.Count<string>() >= 4)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DrawHeatingPipeSetting", "PipeDiameter", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawHeatingPipeSetting", "Level", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawHeatingPipeSetting", "Offset", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DrawHeatingPipeSetting", "slope", texts[3]);
			}
		}

		public string[] Get3DAlighmentsPipeText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "View3DAlighmentsPipe", "FamilySymbol");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "View3DAlighmentsPipe", "witdh");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "View3DAlighmentsPipe", "minLength");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "View3DAlighmentsPipe", "model");
			return array;
		}

		public void Write3DAlighmentsPipeText(string[] texts)
		{
			if (texts.Count<string>() >= 4)
			{
				XMLOperating.EditNodeText(this.xmlPath, "View3DAlighmentsPipe", "FamilySymbol", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "View3DAlighmentsPipe", "witdh", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "View3DAlighmentsPipe", "minLength", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "View3DAlighmentsPipe", "model", texts[3]);
			}
		}

		public void WriteTextMarkText(string[] texts)
		{
			if (texts.Count<string>() >= 3)
			{
				XMLOperating.EditNodeText(this.xmlPath, "View3DTextMark", "Text", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "View3DTextMark", "FFlength", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "View3DTextMark", "CZlength", texts[2]);
			}
		}

		public string[] GetTextMarkText()
		{
			string[] array = new string[]
			{
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "View3DTextMark", "Text");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "View3DTextMark", "FFlength");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "View3DTextMark", "CZlength");
			return array;
		}

		public string[] GetRiserDuctText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductwidth");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductheight");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductdiameter");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductsystemtype");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductCheckStart");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductcomStartTxt");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductCheckEnd");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductcomEndTxt");
			array[8] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductoffsetdown");
			array[9] = XMLOperating.GetNodeText(this.xmlDoc, "riserductcreate", "ductoffsetup");
			return array;
		}

		public void WriteRiserDuctText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductwidth", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductheight", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductdiameter", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductsystemtype", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductCheckStart", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductcomStartTxt", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductCheckEnd", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductcomEndTxt", texts[7]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductoffsetdown", texts[8]);
				XMLOperating.EditNodeText(this.xmlPath, "riserductcreate", "ductoffsetup", texts[9]);
			}
		}

		public string[] GetSubstantialWaterColumnCalculationText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "SubstantialWaterColumnCalculationSetting", "comboBoxGunDiameter");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "SubstantialWaterColumnCalculationSetting", "comboBoxFireDiameter");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "SubstantialWaterColumnCalculationSetting", "comboBoxFireMatireals");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "SubstantialWaterColumnCalculationSetting", "comboBoxFireLength");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "SubstantialWaterColumnCalculationSetting", "textBoxWaterLevels");
			return array;
		}

		public void WriteSubstantialWaterColumnCalculationText(string[] texts)
		{
			if (texts.Count<string>() >= 5)
			{
				XMLOperating.EditNodeText(this.xmlPath, "SubstantialWaterColumnCalculationSetting", "comboBoxGunDiameter", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "SubstantialWaterColumnCalculationSetting", "comboBoxFireDiameter", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "SubstantialWaterColumnCalculationSetting", "comboBoxFireMatireals", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "SubstantialWaterColumnCalculationSetting", "comboBoxFireLength", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "SubstantialWaterColumnCalculationSetting", "textBoxWaterLevels", texts[4]);
			}
		}

		public string[] GetUserDataOfTerminalDistanceText()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "TerminalDistanceSetting", "horizentalDistance");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "TerminalDistanceSetting", "verticalDistance");
			return array;
		}

		public void WriteUserDataOfTerminalDistanceText(string[] texts)
		{
			if (texts.Count<string>() >= 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "TerminalDistanceSetting", "horizentalDistance", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "TerminalDistanceSetting", "verticalDistance", texts[1]);
			}
		}

		public EquipmentCoilParam GetEquipmentCoilText()
		{
			return new EquipmentCoilParam
			{
				StructType = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "structtype"),
				InstallType = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "installtype"),
				ConnectType = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "connecttype"),
				OffSet = Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "offset")),
				Tag = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "tag")),
				Name = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "name"),
				Factory = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoil", "factory")
			};
		}

		public EquipmentCoilSetParam GetEquipmentCoilSetText()
		{
			return new EquipmentCoilSetParam
			{
				SupplyWater = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoilpipeset", "supplypipe")),
				ReturnWater = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoilpipeset", "returnpipe")),
				CoolWater = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoilpipeset", "coolpipe")),
				DefaultValve = XMLOperating.GetNodeText(this.xmlDoc, "equipmentcoilpipeset", "valvepipe")
			};
		}

		public void WriteEquipmentCoilText(EquipmentCoilParam ecp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "structtype", ecp.StructType);
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "installtype", ecp.InstallType);
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "connecttype", ecp.ConnectType);
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "offset", ecp.OffSet.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "tag", ecp.Tag.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "name", ecp.Name);
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoil", "factory", ecp.Factory);
		}

		public void WriteEquipmentCoilSetText(EquipmentCoilSetParam ecsp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoilpipeset", "supplypipe", ecsp.SupplyWater.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoilpipeset", "returnpipe", ecsp.ReturnWater.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoilpipeset", "coolpipe", ecsp.CoolWater.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "equipmentcoilpipeset", "valvepipe", ecsp.DefaultValve);
		}

		public PumpCoilSetParam GetPumpValveText()
		{
			return new PumpCoilSetParam
			{
				SupplyWater = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pumpcoilpipeset", "supplypipe")),
				DefaultValve = XMLOperating.GetNodeText(this.xmlDoc, "pumpcoilpipeset", "valvepipe")
			};
		}

		public void WritePumpValveText(PumpCoilSetParam pcsp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pumpcoilpipeset", "supplypipe", pcsp.SupplyWater.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pumpcoilpipeset", "valvepipe", pcsp.DefaultValve);
		}

		public SystemViewSetParam GetSystemViewText()
		{
			return new SystemViewSetParam
			{
				Ratio = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemViewSet", "ratioSet")),
				DetailLevel = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemViewSet", "detailLevelSet")),
				Angle = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemViewSet", "angleSet")),
				ViewAngle = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SystemViewSet", "viewAngleSet")),
				View3D = Convert.ToBoolean(XMLOperating.GetNodeText(this.xmlDoc, "SystemViewSet", "view3DSet"))
			};
		}

		public void WriteSystemViewText(SystemViewSetParam svsp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "SystemViewSet", "ratioSet", svsp.Ratio.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemViewSet", "detailLevelSet", svsp.DetailLevel.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemViewSet", "angleSet", svsp.Angle.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemViewSet", "viewAngleSet", svsp.ViewAngle.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemViewSet", "view3DSet", svsp.View3D.ToString());
		}

		public AddTitleBlocksSetParam GetAddTitleBlocksText()
		{
			return new AddTitleBlocksSetParam
			{
				Size = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "AddTitleBlocksSet", "sizeSet")),
				Width = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "AddTitleBlocksSet", "widthSet"))
			};
		}

		public void WriteAddTitleBlocksText(AddTitleBlocksSetParam atbsp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "AddTitleBlocksSet", "sizeSet", atbsp.Size.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "AddTitleBlocksSet", "widthSet", atbsp.Width.ToString());
		}

		public DesignNoteSetParam GetDesignNoteText()
		{
			return new DesignNoteSetParam
			{
				Major = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "DesignNoteSet", "majorSet"))
			};
		}

		public void WriteDesignNoteText(DesignNoteSetParam dnsp)
		{
			XMLOperating.EditNodeText(this.xmlPath, "DesignNoteSet", "majorSet", dnsp.Major.ToString());
		}

		public string GetDuctAlignTypeText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "ductalign", "type");
		}

		public void WriteDuctAlignTypeText(string[] texts)
		{
			if (texts.Count<string>() >= 4)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignmentData", "AlignmentModle", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignmentData", "IsUserData", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignmentData", "Height", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignmentData", "SelType", texts[3]);
			}
		}

		public string[] GetDuctAlignTypeText(bool isThree)
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignmentData", "AlignmentModle");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignmentData", "IsUserData");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignmentData", "Height");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignmentData", "SelType");
			return array;
		}

		public void WriteDuctAlignTypeText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductalign", "type", text);
		}

		public DuctFittingSet GetDuctFittingSetText()
		{
			return new DuctFittingSet
			{
				RectFitting = 
				{
					Elbow = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "elbow"),
					Tee = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "tee"),
					Cross = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "cross"),
					TYDF = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "tydf"),
					Transition = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "transition"),
					TakeOff = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "takeoff")
				},
				RoundFitting = 
				{
					Elbow = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "elbowround"),
					Tee = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "teeround"),
					Cross = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "crossround"),
					TYDF = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "tydfround"),
					Transition = XMLOperating.GetNodeText(this.xmlDoc, "ductfittingset", "transitionround")
				}
			};
		}

		public void WriteDuctFittingSetText(DuctFittingSet dfs)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "elbow", dfs.RectFitting.Elbow);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "tee", dfs.RectFitting.Tee);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "cross", dfs.RectFitting.Cross);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "tydf", dfs.RectFitting.TYDF);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "transition", dfs.RectFitting.Transition);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "takeoff", dfs.RectFitting.TakeOff);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "elbowround", dfs.RoundFitting.Elbow);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "teeround", dfs.RoundFitting.Tee);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "crossround", dfs.RoundFitting.Cross);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "tydfround", dfs.RoundFitting.TYDF);
			XMLOperating.EditNodeText(this.xmlPath, "ductfittingset", "transitionround", dfs.RoundFitting.Transition);
		}

		public string GetDWGExportValue()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "dwgsetting", "name");
		}

		public void WriteDWGExportValue(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "dwgsetting", "name", text);
		}

		public string GetRadiatorText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "radiatorlaywindow", "distance");
		}

		public void WriteRadiatorText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "radiatorlaywindow", "distance", text);
		}

		public string GetRadioChecked()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "sprinklers", "arealay");
		}

		public void WriteRadioChecked(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "sprinklers", "arealay", text);
		}

		public LayMidParameter GetLayTerminalMid()
		{
			return new LayMidParameter
			{
				TopDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "topdistance")),
				BottomDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "bottomdistance")),
				LeftDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "leftdistance")),
				RightDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "rightdistance")),
				RowCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "rowcount")),
				ColCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "colcount"))
			};
		}

		public void WriteLayTerminalMid(LayMidParameter lmPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "topdistance", lmPara.TopDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "bottomdistance", lmPara.BottomDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "leftdistance", lmPara.LeftDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "rightdistance", lmPara.RightDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "rowcount", lmPara.RowCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "colcount", lmPara.ColCount.ToString());
		}

		public LayLineParameter GetLaySprinklersLine()
		{
			return new LayLineParameter
			{
				Count = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "count")),
				Ratio = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "ratio")),
				Distance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "distance")),
				DistanceSide = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "sidedistance")),
				LimitFlag = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "limit")),
				OneLine = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelayline", "oneline"))
			};
		}

		public void WriteLaySprinklersLine(LayLineParameter lmPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "count", lmPara.Count.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "ratio", lmPara.Ratio.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "distance", lmPara.Distance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "sidedistance", lmPara.DistanceSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "limit", lmPara.LimitFlag.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelayline", "oneline", lmPara.OneLine.ToString());
		}

		public LayMidParameter GetLaySprinklersMid()
		{
			return new LayMidParameter
			{
				Type = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "type")),
				RowCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "rowcount")),
				ColCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "colcount")),
				LeftDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "leftdistance")),
				RightDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "rightdistance")),
				TopDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "topdistance")),
				BottomDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "bottomdistance")),
				RowDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "rowdistance")),
				ColDistance = (double)int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaymid", "coldistance"))
			};
		}

		public void WriteLaySprinklersMid(LayMidParameter lmPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "type", lmPara.Type.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "rowcount", lmPara.RowCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "colcount", lmPara.ColCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "leftdistance", lmPara.LeftDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "rightdistance", lmPara.RightDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "topdistance", lmPara.TopDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "bottomdistance", lmPara.BottomDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "rowdistance", lmPara.RowDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaymid", "coldistance", lmPara.ColDistance.ToString());
		}

		public LayAreaParameter GetLaySprinklersArea()
		{
			return new LayAreaParameter
			{
				RowCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "rowcount")),
				ColCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "colcount")),
				Ratio = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "ratio")),
				RowDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "rowdistance")),
				ColDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "coldistance")),
				RowDistanceSide = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "rowsidedistance")),
				ColDistanceSide = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "colsidedistance")),
				Danger = XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "danger"),
				LimitFlag = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaybatch", "limit"))
			};
		}

		public void WriteLaySprinklersArea(LayAreaParameter lmPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "rowcount", lmPara.RowCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "colcount", lmPara.ColCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "ratio", lmPara.Ratio.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "rowdistance", lmPara.RowDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "coldistance", lmPara.ColDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "rowsidedistance", lmPara.RowDistanceSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "colsidedistance", lmPara.ColDistanceSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "danger", lmPara.Danger);
			XMLOperating.EditNodeText(this.xmlPath, "pipelaybatch", "limit", lmPara.LimitFlag.ToString());
		}

		public LayAreaParameter GetLaySprinklersLingXing()
		{
			return new LayAreaParameter
			{
				RowCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "rowcount")),
				ColCount = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "colcount")),
				Ratio = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "ratio")),
				RowDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "rowdistance")),
				ColDistance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "coldistance")),
				RowDistanceSide = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "rowsidedistance")),
				ColDistanceSide = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "colsidedistance")),
				Danger = XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "danger"),
				LimitFlag = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "pipelaylingxing", "limit"))
			};
		}

		public void WriteLaySprinklersLingXing(LayAreaParameter lmPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "rowcount", lmPara.RowCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "colcount", lmPara.ColCount.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "ratio", lmPara.Ratio.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "rowdistance", lmPara.RowDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "coldistance", lmPara.ColDistance.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "rowsidedistance", lmPara.RowDistanceSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "colsidedistance", lmPara.ColDistanceSide.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "danger", lmPara.Danger);
			XMLOperating.EditNodeText(this.xmlPath, "pipelaylingxing", "limit", lmPara.LimitFlag.ToString());
		}

		public ConnectionTypeParam GetConnectionType()
		{
			return new ConnectionTypeParam
			{
				Type = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "connectionType", "type")),
				Distance = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "connectionType", "distance"))
			};
		}

		public void WriteConnectionType(ConnectionTypeParam ConnPara)
		{
			XMLOperating.EditNodeText(this.xmlPath, "connectionType", "type", ConnPara.Type.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "connectionType", "distance", ConnPara.Distance.ToString());
		}

		public string GetTerminalConnectionType()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "terminalConnType", "type");
		}

		public void WriteTerminalConnectionType(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "terminalConnType", "type", text);
		}

		public string GetTerminalAlignType()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "terminalConnType", "align");
		}

		public void WriteTerminalAlignType(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "terminalConnType", "align", text);
		}

		public string GetFloorPipeConnType()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeConn", "type");
		}

		public void WriteFloorPipeConnType(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "FloorPipeConn", "type", text);
		}

		public Dictionary<int, double> GetDrawVerticalPipeLength()
		{
			Dictionary<int, double> dictionary = new Dictionary<int, double>();
			try
			{
				dictionary.Add(50, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN50")));
				dictionary.Add(100, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN100")));
				dictionary.Add(199, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN199")));
				dictionary.Add(200, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN200")));
				dictionary.Add(300, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN300")));
				dictionary.Add(1000000, Convert.ToDouble(XMLOperating.GetNodeText(this.xmlDoc, "DrawVerticalLength", "DN1000000")));
			}
			catch (Exception ex)
			{
				string message = ex.Message;
				dictionary.Add(50, 160.0);
				dictionary.Add(100, 260.0);
				dictionary.Add(199, 300.0);
				dictionary.Add(200, 400.0);
				dictionary.Add(300, 500.0);
				dictionary.Add(1000000, 500.0);
			}
			return dictionary;
		}

		public void WriteDrawVerticalPipeLength(Dictionary<int, double> dic)
		{
			foreach (KeyValuePair<int, double> keyValuePair in dic)
			{
				int key = keyValuePair.Key;
				if (key <= 100)
				{
					if (key == 50)
					{
						XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN50", keyValuePair.Value.ToString());
						continue;
					}
					if (key == 100)
					{
						XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN100", keyValuePair.Value.ToString());
						continue;
					}
				}
				else
				{
					if (key == 199)
					{
						XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN199", keyValuePair.Value.ToString());
						continue;
					}
					if (key == 200)
					{
						XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN200", keyValuePair.Value.ToString());
						continue;
					}
					if (key == 300)
					{
						XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN300", keyValuePair.Value.ToString());
						continue;
					}
				}
				XMLOperating.EditNodeText(this.xmlPath, "DrawVerticalLength", "DN1000000", keyValuePair.Value.ToString());
			}
		}

		public void WriteDuctAlignmentPipingFittingText(string[] texts)
		{
			if (texts.Count<string>() >= 6)
			{
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "TeeTop", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "TeeBot", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "CrossTop", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "CrossBot", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "TeeMiddle", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "DuctAlignMentFittingSetInfo", "CrossMiddle", texts[5]);
			}
		}

		public string[] GetDuctAlignmentPipingFittingText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "TeeTop");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "TeeBot");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "CrossTop");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "CrossBot");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "TeeMiddle");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "DuctAlignMentFittingSetInfo", "CrossMiddle");
			return array;
		}

		public List<string[]> ReadPipingFittingSetInfo(string nodeName)
		{
			XmlNode xmlNode = this.xmlDoc.ChildNodes[0];
			XmlNodeList childNodes = this.xmlDoc.SelectSingleNode(xmlNode.Name).ChildNodes;
			XmlNodeList xmlNodeList = null;
			List<string[]> list = new List<string[]>();
			bool flag = false;
			foreach (object obj in childNodes)
			{
				XmlElement xmlElement = (XmlElement)((XmlNode)obj);
				if (xmlElement.Name == nodeName)
				{
					xmlNodeList = xmlElement.ChildNodes;
					flag = true;
					break;
				}
			}
			if (flag)
			{
				IEnumerator enumerator = xmlNodeList.GetEnumerator();
				{
					while (enumerator.MoveNext())
					{
						object obj2 = enumerator.Current;
						XmlNode xmlNode2 = (XmlNode)obj2;
						list.Add(new string[]
						{
							xmlNode2.Name,
							xmlNode2.Value
						});
					}
					return list;
				}
			}
			return null;
		}

		public void WritePipingFittingSetInfo(string nodeName, List<string[]> list)
		{
			XmlNode xmlNode = this.xmlDoc.ChildNodes[0];
			XmlNodeList childNodes = this.xmlDoc.SelectSingleNode(xmlNode.Name).ChildNodes;
			XmlNode xmlNode2 = null;
			bool flag = false;
			foreach (object obj in childNodes)
			{
				XmlNode xmlNode3 = (XmlNode)obj;
				if (((XmlElement)xmlNode3).Name == nodeName)
				{
					xmlNode2 = xmlNode3;
					flag = true;
					break;
				}
			}
			if (flag)
			{
				xmlNode2.RemoveAll();
			}
			else
			{
				XmlNode xmlNode4 = this.xmlDoc.CreateElement(nodeName);
				xmlNode.AppendChild(xmlNode4);
				xmlNode2 = xmlNode4;
			}
			foreach (string[] array in list)
			{
				XmlNode xmlNode5 = this.xmlDoc.CreateElement(array[0]);
				xmlNode5.Value = array[1];
				xmlNode2.AppendChild(xmlNode5);
			}
		}

		public string[] GetAirTerminalText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "name");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "arrowtype");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "offset");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "allflow");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "terminalcount");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "hongyeOrCurrentProject");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "CurrentProjectType");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "airterminal", "AreaCoefficient");
			return array;
		}

		public void WriteAirTerminalText(string[] texts)
		{
			if (texts.Count<string>() >= 5)
			{
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "name", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "arrowtype", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "offset", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "allflow", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "terminalcount", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "hongyeOrCurrentProject", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "CurrentProjectType", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "airterminal", "AreaCoefficient", texts[7]);
			}
		}

		public string[] GetSideAirTerminalLayInfo()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "SideTerminalLineLay", "BaseLayPoint");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "SideTerminalLineLay", "LayDistance");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "SideTerminalLineLay", "PointDistance");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "SideTerminalLineLay", "BeNum");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "SideTerminalLineLay", "TerminalNum");
			return array;
		}

		public void WriteSideAirTerminalInfo(string[] texts)
		{
			if (texts.Count<string>() >= 5)
			{
				XMLOperating.EditNodeText(this.xmlPath, "SideTerminalLineLay", "BaseLayPoint", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "SideTerminalLineLay", "LayDistance", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "SideTerminalLineLay", "PointDistance", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "SideTerminalLineLay", "BeNum", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "SideTerminalLineLay", "TerminalNum", texts[4]);
			}
		}

		public string[] GetTerminalLayMidText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "rowcount");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "colcount");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "topdistance");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "bottomdistance");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "leftdistance");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "rightdistance");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "rowdistance");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "coldistance");
			array[8] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaymid", "limit");
			return array;
		}

		public void WriteTerminalLayMidText(string[] texts)
		{
			if (texts.Count<string>() >= 9)
			{
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "rowcount", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "colcount", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "topdistance", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "bottomdistance", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "leftdistance", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "rightdistance", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "rowdistance", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "coldistance", texts[7]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaymid", "limit", texts[8]);
			}
		}

		public GarageLineParam GetGarageInterFaceInfo()
		{
			GarageLineParam garageLineParam = new GarageLineParam();
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "EvenNumDistance");
			garageLineParam.EvenNumDistance = this.GetXmlTextOrDefaultValue(nodeText, "250");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "InstallOffset");
			garageLineParam.InstallOffset = this.GetXmlTextOrDefaultValue(nodeText, "2.5");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "JZLDistance");
			garageLineParam.JZLDistance = this.GetXmlTextOrDefaultValue(nodeText, "725");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "LightLayStyle");
			garageLineParam.LightLayStyle = this.GetXmlTextOrDefaultValue(nodeText, "单");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "OddNumDistance");
			garageLineParam.OddNumDistance = this.GetXmlTextOrDefaultValue(nodeText, "250");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "SZLLayStyle");
			garageLineParam.SZLLayStyle = this.GetXmlTextOrDefaultValue(nodeText, "居中");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "YZLDirection");
			garageLineParam.YZLDirection = this.GetXmlTextOrDefaultValue(nodeText, "上/左");
			nodeText = XMLOperating.GetNodeText(this.xmlDoc, "GarageLineSetting", "YZLDistance");
			garageLineParam.YZLDistance = this.GetXmlTextOrDefaultValue(nodeText, "725");
			return garageLineParam;
		}

		public void SaveGarageLineInterfaceInfo(GarageLineParam glParam)
		{
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "EvenNumDistance", glParam.EvenNumDistance);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "InstallOffset", glParam.InstallOffset);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "JZLDistance", glParam.JZLDistance);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "LightLayStyle", glParam.LightLayStyle);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "OddNumDistance", glParam.OddNumDistance);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "SZLLayStyle", glParam.SZLLayStyle);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "YZLDirection", glParam.YZLDirection);
			XMLOperating.EditNodeText(this.xmlPath, "GarageLineSetting", "YZLDistance", glParam.YZLDistance);
		}

		private string GetXmlTextOrDefaultValue(string xmlText, string defaultText)
		{
			string text = xmlText;
			if (string.IsNullOrEmpty(text))
			{
				text = defaultText;
			}
			return text;
		}

		public string[] GetTerminalLayRectText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "limit");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "rowcount");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "colcount");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "ratio");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "rowdistance");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "coldistance");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "rowsidedistance");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "colsidedistance");
			array[8] = XMLOperating.GetNodeText(this.xmlDoc, "ductlaybatch", "rowangle");
			return array;
		}

		public void WriteTerminalLayRectText(string[] texts)
		{
			if (texts.Count<string>() >= 9)
			{
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "limit", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "rowcount", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "colcount", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "ratio", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "rowdistance", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "coldistance", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "rowsidedistance", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "colsidedistance", texts[7]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlaybatch", "rowangle", texts[8]);
			}
		}

		public string[] GetTerminalLayLineText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "ductlayline", "limit");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "ductlayline", "count");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "ductlayline", "ratio");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "ductlayline", "distance");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "ductlayline", "sidedistance");
			return array;
		}

		public void WriteTerminalLayLineText(string[] texts)
		{
			if (texts.Count<string>() >= 5)
			{
				XMLOperating.EditNodeText(this.xmlPath, "ductlayline", "limit", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlayline", "count", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlayline", "ratio", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlayline", "distance", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "ductlayline", "sidedistance", texts[4]);
			}
		}

		public string GetTerminalLayText()
		{
			return XMLOperating.GetNodeText(this.xmlDoc, "layairterminaltype", "type");
		}

		public void WriteTerminalLayText(string text)
		{
			XMLOperating.EditNodeText(this.xmlPath, "layairterminaltype", "type", text);
		}

		public SystemUpDownSetPara GetSystemUpDownPara()
		{
			return new SystemUpDownSetPara
			{
				Style = int.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemUpDownPara", "style")),
				UpTo = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemUpDownPara", "upto")),
				UpBy = double.Parse(XMLOperating.GetNodeText(this.xmlDoc, "SystemUpDownPara", "upby"))
			};
		}

		public void SetSystemUpDownPara(SystemUpDownSetPara sysup)
		{
			XMLOperating.EditNodeText(this.xmlPath, "SystemUpDownPara", "style", sysup.Style.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemUpDownPara", "upto", sysup.UpTo.ToString());
			XMLOperating.EditNodeText(this.xmlPath, "SystemUpDownPara", "upby", sysup.UpBy.ToString());
		}

		public string[] GetpianyishengjiangText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "SJDistance");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "SJAngle");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "SJmodel");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "PYDistance");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "PYAngle");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "PYmodel");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "PianYiShengJiang", "PYOrSJ");
			return array;
		}

		public void WritepianyishengjiangText(string[] texts)
		{
			if (texts.Count<string>() >= 7)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "SJDistance", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "SJAngle", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "SJmodel", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "PYDistance", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "PYAngle", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "PYmodel", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "PianYiShengJiang", "PYOrSJ", texts[6]);
			}
		}

		public string[] GetLayExtinguisherText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "pipenet");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "singlebottle");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "singlerank");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "planscale");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "volume");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "realscale");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "planscale2");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "volume2");
			array[8] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "realscale2");
			array[9] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "locationX");
			array[10] = XMLOperating.GetNodeText(this.xmlDoc, "LayExtinguisher", "locationY");
			return array;
		}

		public void WriteLayExtinguisherText(string[] texts)
		{
			if (texts.Count<string>() >= 11)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "pipenet", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "singlebottle", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "singlerank", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "planscale", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "volume", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "realscale", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "planscale2", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "volume2", texts[7]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "realscale2", texts[8]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "locationX", texts[9]);
				XMLOperating.EditNodeText(this.xmlPath, "LayExtinguisher", "locationY", texts[10]);
			}
		}

		public string[] GetCalHFCSettingText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "concentration");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "Volume");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "Mintemperature");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "AltitudeCorrectionFactor");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "Pressure");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "BlowTime");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "locationX");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "CalHFCSetting", "locationY");
			return array;
		}

		public void WriteCalHFCSettingText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "concentration", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "Volume", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "Mintemperature", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "AltitudeCorrectionFactor", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "Pressure", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "BlowTime", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "locationX", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "CalHFCSetting", "locationY", texts[7]);
			}
		}

		public string[] GetLayFireVoltageEquipmentText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "overH");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "overH1");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "overH2");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "underH");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "underH2");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "voltageFlowQ");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "adjustVolumeSafetyFactor");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "adjustVolumeStartTimes");
			array[8] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "locationX");
			array[9] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "locationY");
			array[10] = XMLOperating.GetNodeText(this.xmlDoc, "LayFireVoltageEquipment", "WXBLocation");
			return array;
		}

		public void WriteLayFireVoltageEquipmentText(string[] texts)
		{
			if (texts.Count<string>() >= 11)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "overH", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "overH1", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "overH2", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "underH", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "underH2", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "voltageFlowQ", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "adjustVolumeSafetyFactor", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "adjustVolumeStartTimes", texts[7]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "locationX", texts[8]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "locationY", texts[9]);
				XMLOperating.EditNodeText(this.xmlPath, "LayFireVoltageEquipment", "WXBLocation", texts[10]);
			}
		}

		public string[] GetFrmHYStandardText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colPipingType");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colAbb");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colLineColor");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colLinePattern");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colLineWeight");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "colClassify");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "sizeWidth");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandard", "sizeHeight");
			return array;
		}

		public void WriteFrmHYStandardText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colPipingType", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colAbb", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colLineColor", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colLinePattern", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colLineWeight", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "colClassify", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "sizeWidth", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandard", "sizeHeight", texts[7]);
			}
		}

		public string[] GetFrmHYStandardHeatingText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colPipingType");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colAbb");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colLineColor");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colLinePattern");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colLineWeight");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "colClassify");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "sizeWidth");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "FrmHYStandardHeating", "sizeHeight");
			return array;
		}

		public void WriteFrmHYStandardHeatingText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colPipingType", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colAbb", texts[1]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colLineColor", texts[2]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colLinePattern", texts[3]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colLineWeight", texts[4]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "colClassify", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "sizeWidth", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "FrmHYStandardHeating", "sizeHeight", texts[7]);
			}
		}

		public string[] GetRefrigerantPipeCreateText()
		{
			string[] array = new string[]
			{
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "RefrigerantPipeCreate", "GasLiquidIntegration");
			return array;
		}

		public void WriteRefrigerantPipeCreateText(string[] texts)
		{
			if (texts.Count<string>() >= 1)
			{
				XMLOperating.EditNodeText(this.xmlPath, "RefrigerantPipeCreate", "GasLiquidIntegration", texts[0]);
			}
		}

		public IDictionary<string, string> GetVRefrigerantPipeInfo()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			string nodeText = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsIntegratedPipe");
			string nodeText2 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsGasPipe");
			string nodeText3 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "LiquidDiameter");
			string nodeText4 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "GasDiameter");
			string nodeText5 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsLocateAssist");
			string nodeText6 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "AssistLength");
			string nodeText7 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "AssistAngle");
			string nodeText8 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsCustom");
			string nodeText9 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "CustomNum");
			string nodeText10 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsAreaNum");
			string nodeText11 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "AreaNum");
			string nodeText12 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsBuildingNum");
			string nodeText13 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "BuildingNum");
			string nodeText14 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "IsRelative");
			string nodeText15 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "StartRefer");
			string nodeText16 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "StartOffset");
			string nodeText17 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "EndRefer");
			string nodeText18 = XMLOperating.GetNodeText(this.xmlDoc, "VRefrigerantPipeInfo", "EndOffset");
			((IDictionary<string, string>)dictionary).Add("IsIntegratedPipe", nodeText);
			((IDictionary<string, string>)dictionary).Add("IsGasPipe", nodeText2);
			((IDictionary<string, string>)dictionary).Add("LiquidDiameter", nodeText3);
			((IDictionary<string, string>)dictionary).Add("GasDiameter", nodeText4);
			((IDictionary<string, string>)dictionary).Add("IsLocateAssist", nodeText5);
			((IDictionary<string, string>)dictionary).Add("AssistLength", nodeText6);
			((IDictionary<string, string>)dictionary).Add("AssistAngle", nodeText7);
			((IDictionary<string, string>)dictionary).Add("IsCustom", nodeText8);
			((IDictionary<string, string>)dictionary).Add("CustomNum", nodeText9);
			((IDictionary<string, string>)dictionary).Add("IsAreaNum", nodeText10);
			((IDictionary<string, string>)dictionary).Add("AreaNum", nodeText11);
			((IDictionary<string, string>)dictionary).Add("IsBuildingNum", nodeText12);
			((IDictionary<string, string>)dictionary).Add("BuildingNum", nodeText13);
			((IDictionary<string, string>)dictionary).Add("IsRelative", nodeText14);
			((IDictionary<string, string>)dictionary).Add("StartRefer", nodeText15);
			((IDictionary<string, string>)dictionary).Add("StartOffset", nodeText16);
			((IDictionary<string, string>)dictionary).Add("EndRefer", nodeText17);
			((IDictionary<string, string>)dictionary).Add("EndOffset", nodeText18);
			return dictionary;
		}

		public void WriteVRefrigerantPipeInfo(IDictionary<string, string> userData)
		{
			if (userData == null || userData.Count <= 0)
			{
				return;
			}
			foreach (string text in userData.Keys)
			{
				XMLOperating.EditNodeText(this.xmlPath, "VRefrigerantPipeInfo", text, userData[text]);
			}
		}

		public string[] GetIndoorAutomaticLayoutText()
		{
			string[] array = new string[]
			{
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "IndoorAutomaticLayout", "SelectionMethod");
			return array;
		}

		public void WriteIndoorAutomaticLayoutText(string[] texts)
		{
			if (texts.Count<string>() >= 1)
			{
				XMLOperating.EditNodeText(this.xmlPath, "IndoorAutomaticLayout", "SelectionMethod", texts[0]);
			}
		}

		public string[] GetIndoorAutomaticLayoutSettingText()
		{
			string[] array = new string[]
			{
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "IndoorAutomaticLayoutSetting", "SwitchArrange");
			return array;
		}

		public void WriteIndoorAutomaticLayoutSettingText(string[] texts)
		{
			if (texts.Count<string>() >= 1)
			{
				XMLOperating.EditNodeText(this.xmlPath, "IndoorAutomaticLayoutSetting", "SwitchArrange", texts[0]);
			}
		}

		public string[] GetMultilineSettingText()
		{
			string[] array = new string[]
			{
				"",
				"",
				"",
				"",
				"",
				"",
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "BifurcationPipeFill");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "BifurcationPipeSize");
			array[2] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "BifurcationPipeLength");
			array[3] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "RefrigerantPipeProlongLength");
			array[4] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "CondenserPipeProlongLength");
			array[5] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "RefrigerantPipeTagPrefix");
			array[6] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "RefrigerantPipeTagFormat");
			array[7] = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "ManufactorName");
			return array;
		}

		public string GetVRVDimPreFix()
		{
			string text = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "RefrigerantPipeTagPrefix");
			if (text == "无")
			{
				text = "";
			}
			return text;
		}

		public string GetVRVDimSpliter()
		{
			string text = XMLOperating.GetNodeText(this.xmlDoc, "MultilineSetting", "RefrigerantPipeTagFormat");
			if (text == "空格")
			{
				text = " ";
			}
			return text;
		}

		public void WriteMultilineSettingText(string[] texts)
		{
			if (texts.Count<string>() >= 8)
			{
				XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "BifurcationPipeFill", texts[0]);
				if (texts[1] != null)
				{
					XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "BifurcationPipeSize", texts[1]);
				}
				if (texts[2] != null)
				{
					XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "BifurcationPipeLength", texts[2]);
				}
				if (texts[3] != null)
				{
					XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "RefrigerantPipeProlongLength", texts[3]);
				}
				if (texts[4] != null)
				{
					XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "CondenserPipeProlongLength", texts[4]);
				}
				XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "RefrigerantPipeTagPrefix", texts[5]);
				XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "RefrigerantPipeTagFormat", texts[6]);
				XMLOperating.EditNodeText(this.xmlPath, "MultilineSetting", "ManufactorName", texts[7]);
			}
		}

		public string[] GetFactorImportSettingText()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "FactorImportSetting", "Factor");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "FactorImportSetting", "Model");
			return array;
		}

		public void WriteFactorImportSettingText(string[] texts)
		{
			if (texts.Count<string>() >= 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FactorImportSetting", "Factor", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "FactorImportSetting", "Model", texts[1]);
			}
		}

		public string[] GetDuctConnectEquimentBatchText()
		{
			string[] array = new string[]
			{
				"",
				""
			};
			array[0] = XMLOperating.GetNodeText(this.xmlDoc, "EquimentBatch", "UseFlex");
			array[1] = XMLOperating.GetNodeText(this.xmlDoc, "EquimentBatch", "Length");
			return array;
		}

		public void WriteDuctConnectEquimentBatchText(string[] texts)
		{
			if (texts.Count<string>() >= 2)
			{
				XMLOperating.EditNodeText(this.xmlPath, "EquimentBatch", "UseFlex", texts[0]);
				XMLOperating.EditNodeText(this.xmlPath, "EquimentBatch", "Length", texts[1]);
			}
		}

		public Dictionary<string, string> GetFloorPipeDrawSetting()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new DrawFloorPipeData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeDraw", propertyInfo.Name));
			}
			dictionary.Add("LayInRoom", XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeDraw", "LayInRoom"));
			dictionary.Add("MarkTag", XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeDraw", "MarkTag"));
			dictionary.Add("BelinkSelect", XMLOperating.GetNodeText(this.xmlDoc, "FloorPipeDraw", "BelinkSelect"));
			return dictionary;
		}

		public Dictionary<string, string> GetFloorPipeDrawSetting(string strSelFloorPipeDraw)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new DrawFloorPipeData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, strSelFloorPipeDraw, propertyInfo.Name));
			}
			dictionary.Add("LayInRoom", XMLOperating.GetNodeText(this.xmlDoc, strSelFloorPipeDraw, "LayInRoom"));
			dictionary.Add("MarkTag", XMLOperating.GetNodeText(this.xmlDoc, strSelFloorPipeDraw, "MarkTag"));
			dictionary.Add("BelinkSelect", XMLOperating.GetNodeText(this.xmlDoc, strSelFloorPipeDraw, "BelinkSelect"));
			return dictionary;
		}

		public void WriteFloorPipeDrawSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FloorPipeDraw", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public void WriteFloorPipeDrawSetting(Dictionary<string, string> dicLaySetting, string strPgStyle)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, strPgStyle, keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetCalculateHeatParam()
		{
			return new Dictionary<string, string>
			{
				{
					"heatLayer",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "heatLayer")
				},
				{
					"groundLayer",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "groundLayer")
				},
				{
					"heatPipeType",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "heatPipeType")
				},
				{
					"averageWater",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "averageWater")
				},
				{
					"indoorAirTemperature",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "indoorAirTemperature")
				},
				{
					"heatPipeDistance",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "heatPipeDistance")
				},
				{
					"layArea",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "layArea")
				},
				{
					"totalHeat",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "totalHeat")
				},
				{
					"calculateType",
					XMLOperating.GetNodeText(this.xmlDoc, "calculateHeat", "calculateType")
				}
			};
		}

		public void WriteCalculateHeatParam(Dictionary<string, string> dicHeatSetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicHeatSetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "calculateHeat", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetYxFloorPipeDrawSetting()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new DrawYxFloorPipeData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, "FloorYxPipeDraw", propertyInfo.Name));
			}
			dictionary.Add("bLayInRoom", XMLOperating.GetNodeText(this.xmlDoc, "FloorYxPipeDraw", "bLayInRoom"));
			dictionary.Add("MarkTag", XMLOperating.GetNodeText(this.xmlDoc, "FloorYxPipeDraw", "MarkTag"));
			dictionary.Add("BeLinkSelect", XMLOperating.GetNodeText(this.xmlDoc, "FloorYxPipeDraw", "BeLinkSelect"));
			return dictionary;
		}

		public Dictionary<string, string> GetYxFloorPipeDrawSetting(string strLineTypeName)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new DrawYxFloorPipeData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, strLineTypeName, propertyInfo.Name));
			}
			dictionary.Add("bLayInRoom", XMLOperating.GetNodeText(this.xmlDoc, strLineTypeName, "bLayInRoom"));
			dictionary.Add("MarkTag", XMLOperating.GetNodeText(this.xmlDoc, strLineTypeName, "MarkTag"));
			dictionary.Add("BeLinkSelect", XMLOperating.GetNodeText(this.xmlDoc, strLineTypeName, "BeLinkSelect"));
			return dictionary;
		}

		public void WriteYxFloorPipeDrawSetting(Dictionary<string, string> dicLaySetting)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, "FloorYxPipeDraw", keyValuePair.Key, keyValuePair.Value);
			}
		}

		public void WriteYxFloorPipeDrawSetting(Dictionary<string, string> dicLaySetting, string strLineTypeName)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dicLaySetting)
			{
				XMLOperating.EditNodeText(this.xmlPath, strLineTypeName, keyValuePair.Key, keyValuePair.Value);
			}
		}

		public Dictionary<string, string> GetSinglePumpSelectionData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new SinglePumpSelectionData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, "singlePumpData", propertyInfo.Name));
			}
			return dictionary;
		}

		public Dictionary<string, string> GetGroupPumpSelectionData()
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			foreach (PropertyInfo propertyInfo in new GroupPumpSelectionData().GetType().GetProperties())
			{
				dictionary.Add(propertyInfo.Name, XMLOperating.GetNodeText(this.xmlDoc, "groupPumpData", propertyInfo.Name));
			}
			return dictionary;
		}

		public void WriteUserData(Dictionary<string, string> dic, string noteName)
		{
			foreach (KeyValuePair<string, string> keyValuePair in dic)
			{
				XMLOperating.EditNodeText(this.xmlPath, noteName, keyValuePair.Key, keyValuePair.Value);
			}
		}

		public void WriteValue(string parentName, string subName, string value)
		{
			XMLOperating.EditNodeText(this.xmlPath, parentName, subName, value);
		}

		public string ReadValue(string parentName, string subName)
		{
			return XMLOperating.GetNodeText(this.xmlDoc, parentName, subName);
		}

		public void WriteReliefInfo(string[] settings)
		{
			if (settings.Count<string>() == 6)
			{
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "IsAutoSelection", settings[0]);
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "AreaSize", settings[1]);
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "Number", settings[2]);
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "Model", settings[3]);
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "Company", settings[4]);
				XMLOperating.EditNodeText(this.xmlPath, "LayRelief", "IsLinkedDocument", settings[5]);
			}
		}

		public string[] ReadReliefInfo()
		{
			return new string[]
			{
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "IsAutoSelection"),
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "AreaSize"),
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "Number"),
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "Model"),
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "Company"),
				XMLOperating.GetNodeText(this.xmlDoc, "LayRelief", "IsLinkedDocument")
			};
		}

		public string[] ReadPipeSettingInfo()
		{
			return new string[]
			{
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "Width"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "Height"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colSysType"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colAbb"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colPipeType"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colLineColor"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colLinePattern"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colLineWeight"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colPipingCategory"),
				XMLOperating.GetNodeText(this.xmlDoc, "PipeSetting", "colPipingGroup")
			};
		}

		public string[] ReadWarmPipeSettingInfo()
		{
			return new string[]
			{
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "Width"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "Height"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colSysType"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colAbb"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colPipeType"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colLineColor"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colLinePattern"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colLineWeight"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colPipingCategory"),
				XMLOperating.GetNodeText(this.xmlDoc, "WarmPipeSetting", "colPipingGroup")
			};
		}

		public void WritePipeSettingInfo(string[] settings)
		{
			if (settings.Count<string>() == 10)
			{
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "Width", settings[0]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "Height", settings[1]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colSysType", settings[2]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colAbb", settings[3]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colPipeType", settings[4]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colLineColor", settings[5]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colLinePattern", settings[6]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colLineWeight", settings[7]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colPipingCategory", settings[8]);
				XMLOperating.EditNodeText(this.xmlPath, "PipeSetting", "colPipingGroup", settings[9]);
			}
		}

		public void WriteWarmPipeSettingInfo(string[] settings)
		{
			if (settings.Count<string>() == 10)
			{
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "Width", settings[0]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "Height", settings[1]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colSysType", settings[2]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colAbb", settings[3]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colPipeType", settings[4]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colLineColor", settings[5]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colLinePattern", settings[6]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colLineWeight", settings[7]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colPipingCategory", settings[8]);
				XMLOperating.EditNodeText(this.xmlPath, "WarmPipeSetting", "colPipingGroup", settings[9]);
			}
		}

		private XmlDocument xmlDoc;

		private string xmlPath = "";
	}
}
